{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "white-energy",
   "metadata": {},
   "source": [
    "# Quantum Kernel Methods\n",
    "\n",
    "<em> Copyright (c) 2021 Institute for Quantum Computing, Baidu Inc. All Rights Reserved. </em>"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "perfect-marker",
   "metadata": {},
   "source": [
    "## Introduction\n",
    "\n",
    "One of the most important learning models for quantum machine learning applications in the noisy intermediate-scale quantum (NISQ) era is the parameterized quantum circuit. Although given its obvious analogy to classical neural networks, many refer to such quantum models as \"quantum neural networks\", it was shown that the mathematical form of such quantum machine learning models is actually much closer to kernel methods, a different kind of classical learning approach [1]. By combining classical kernel methods and the power of quantum models, quantum kernel methods can shed new light on how to approach a variety of machine learning problems, thus raising great interest in the field of quantum machine learning [2-7]. In this tutorial, we will introduce the basic ideas of quantum kernel methods and demonstrate how to classify data with two different quantum kernels.\n",
    "\n",
    "### Background\n",
    "\n",
    "In classical machine learning, kernel methods' basic idea is to map a low-dimensional data vector into a potentially high-dimensional feature space via a feature map, thus giving us the possibility to use linear methods to analyze non-linear features in the original data. As shown in Fig. 1, by mapping linearly inseparable 1D data into a 2D feature space, the feature vectors of the original data become linearly separable.\n",
    "\n",
    "![feature map](./figures/Qkernel-fig-featuremap.png \"Figure 1. feature map in kernel methods\")\n",
    "<div style=\"text-align:center\">Figure 1. feature map in kernel methods </div>\n",
    "\n",
    "In practice, the feature space's dimensionality sometimes can be extremely large (even goes to infinity). So we do not wish to tackle these feature vectors directly. Another key idea in kernel methods is that we can implicitly analyze these feature vectors by only accessing their inner products in the feature space, which is noted as kernel functions $K(,)$:\n",
    "\n",
    "$$\n",
    "K(\\mathbf{x}_i, \\mathbf{x}_j) = \\phi(\\mathbf{x}_j)^T \\phi(\\mathbf{x}_i),\n",
    "\\tag{1}\n",
    "$$\n",
    "\n",
    "with $\\phi()$ being the feature map. We note that in kernel methods, we do not need to express the feature map explicitly. Instead, we only need to compute the kernel function. This approach can introduce non-linearity into our models, giving us the ability to recognize intractable patterns in the original data space.   \n",
    "\n",
    "The arguably most famous application of kernel methods is the support vector machine (SVM), which solves linear classification problems. Take a 2-classification problem as an example: Given data set $T = \\{ (\\mathbf{x}_1, y_1), ..., (\\mathbf{x}_m, y_m) \\} \\subset \\mathcal{X}\\times\\mathbb{Z}_2$, with a hyperplane $( \\mathbf{w}, b)$, a support vector machine can assign labels via the signs of the decision function, as:\n",
    "\n",
    "$$\n",
    "y_{\\rm pred} = {\\rm sign}(\\langle \\mathbf{w}, \\mathbf{x} \\rangle + b).\n",
    "\\tag{2}\n",
    "$$\n",
    "\n",
    "But for linearly inseparable data, such linear classification schemes do not work. So again, as shown in Fig. 1, we can potentially find a better separation by mapping them into a feature space. For example, if we note the separating hyperplane in the feature space as $(\\mathbf{w}', b')$, then the decision function becomes:\n",
    "\n",
    "$$\n",
    "y_{\\rm pred} = {\\rm sign}(\\langle \\mathbf{w}', \\phi(\\mathbf{x}) \\rangle + b').\n",
    "\\tag{3}\n",
    "$$\n",
    "\n",
    "Furthermore, by duality, we can write the hyperplane as $\\mathbf{w}' = \\sum_i \\alpha_i \\phi(\\mathbf{x_i})$ with Lagrangian multipliers $\\alpha_i$ [8]. Then, under the constraints $\\alpha_i \\geq 0$ and $\\sum_i y_i \\alpha_i=0$, we can compute the optimal $\\alpha_i^*$, thus the optimal hyperplane by maximizing \n",
    "\n",
    "$$\n",
    "\\sum_i \\alpha_i - \\frac{1}{2} \\sum_{i, j} \\alpha_i \\alpha_j y_i y_j \\phi(\\mathbf{x}_j)^T \\phi(\\mathbf{x}_i).\n",
    "\\tag{4}\n",
    "$$\n",
    "\n",
    "Notice that in Eq. (4), we only need the inner products of feature vectors $\\phi(\\mathbf{x}_j)^T \\phi(\\mathbf{x}_i) = K(x_i, x_j)$, which is the above mentioned kernel function. As a result, we are able to find the optimal separating hyperplane in the feature space with SVM by only accessing the feature space through the kernel function. Furthermore, we can compute the predicted label as follows:\n",
    "\n",
    "$$\n",
    "y_{\\rm pred} = {\\rm sign}(\\sum_i \\alpha^*_i  \\langle \\phi(\\mathbf{x_i}), \\phi(\\mathbf{x}' \\rangle + b') = \n",
    "{\\rm sign}(\\sum_i \\alpha^*_i  K(\\mathbf{x}_i, \\mathbf{x}') + b').\n",
    "\\tag{5}\n",
    "$$\n",
    "\n",
    "Again, only kernel function is needed. \n",
    "\n",
    "Given the idea of classical kernel methods, we can easily understand the essential idea of quantum kernel methods. First, consider a quantum feature space, where we map a classical data vector $\\mathbf{x}$ into a quantum state $| \\phi(\\mathbf{x})\\rangle$ by a encoding circuit $U(\\mathbf{x})$ as follows:\n",
    "\n",
    "$$\n",
    "U(\\mathbf{x}) | 0^{\\otimes N} \\rangle = | \\phi(\\mathbf{x}) \\rangle.\n",
    "\\tag{6}\n",
    "$$\n",
    "\n",
    "There are many discussions about how to best design an encoding circuit. We refer to our [data encoding tutorial](./DataEncoding_EN.ipynb) for a more detailed explanation. The encoding can also be regarded as a quantum feature map from classical data space to the Hilbert space. Based on this idea, we define a quantum kernel function as the inner products of two quantum feature vectors in the Hilbert space, which is\n",
    "\n",
    "$$\n",
    "K^Q_{ij} = |\\langle \\phi(\\mathbf{x}_j) | \\phi(\\mathbf{x}_i) \\rangle |^2,\n",
    "\\tag{7}\n",
    "$$\n",
    "\n",
    "which can be further formulated as\n",
    "\n",
    "$$\n",
    "|\\langle \\phi(\\mathbf{x}_j) | \\phi(\\mathbf{x}_i) \\rangle |^2 =  |\\langle 0^{\\otimes N} | U^\\dagger(\\mathbf{x}_j) U(\\mathbf{x}_i) | 0^{\\otimes N} \\rangle |^2.\n",
    "\\tag{8}\n",
    "$$\n",
    "\n",
    "By running the quantum circuit as shown in Fig. 2, and measure the probability of observing $| 0^{\\otimes N} \\rangle $ at the output, we can estimate the quantum kernel function in Eq. (8). This way of constructing quantum kernels is also known as quantum kernel estimation (QKE). By replacing the classical kernel function in Eq. (4-5) with QKE, we can classify data in the quantum feature space with SVM. Given the potentially non-simulatable nature of such quantum kernels, there might exist a quantum advantage in recognizing classically intractable patterns. Such an advantage has been rigorously shown, with a constructed classically hard classification problem and a carefully designed quantum feature map [3].\n",
    "\n",
    "![QKE](./figures/Qkernel-fig-QKE.png \"Figure 2. Quantum kernel estimation circuit\")\n",
    "<div style=\"text-align:center\">Figure 2. Quantum kernel estimation circuit </div>\n",
    "\n",
    "![illustration](./figures/Qkernel-fig-illustrationEN.png \"Figure 3. Classical kernel methods and quantum kernel methods\")\n",
    "<div style=\"text-align:center\">Figure 3. Classical kernel methods and quantum kernel methods </div>"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "parental-tampa",
   "metadata": {},
   "source": [
    "### Connections between quantum machine learning and kernel methods\n",
    "\n",
    "In quantum machine learning models, a quantum encoding circuit is often used to encode classical data into a quantum state\n",
    "\n",
    "$$\n",
    "| \\phi(x) \\rangle = U (x) | 0^{\\otimes N} \\rangle,\n",
    "\\tag{9}\n",
    "$$\n",
    "\n",
    "where $U(x)$ is a parameterized quantum circuit depending on the data vector $x$. Like we mentioned above, such quantum encoding circuit can be considered as a quantum feature map. Then, consider a \"quantum neural network\" is applied to the encoding state, in which the quantum circuit is composed of a set of parameterized gates with variational parameters. We have the final state as\n",
    "\n",
    "$$\n",
    "| \\psi \\rangle = U_{\\rm QNN}(\\theta)U (\\mathbf{x}) | 0^{\\otimes N} \\rangle,\n",
    "\\tag{10}\n",
    "$$\n",
    "\n",
    "where $U_{\\rm QNN}(\\theta)$ is the quantum neural network with parameters $\\theta$. Finally we perform a measurement $\\mathcal{M}$ on the final state as the output of our model, its expectation value can be computed as\n",
    "\n",
    "$$\n",
    "\\langle \\mathcal{M} \\rangle = \\langle \\psi | \\mathcal{M} | \\psi \\rangle = \\langle \\phi(\\mathbf{x}) | U^\\dagger_{\\rm QNN}(\\theta) \\mathcal{M} U_{\\rm QNN}(\\theta)| \\phi(\\mathbf{x}) \\rangle.\n",
    "\\tag{11}\n",
    "$$\n",
    "\n",
    "Suppose we write the measurement in its operator form $| \\sigma \\rangle \\langle \\sigma |$, then Eq. (11) can be further reformulated as \n",
    "\n",
    "$$\n",
    "\\langle \\phi(\\mathbf{x}) | \\sigma'(\\theta) \\rangle \\langle \\sigma' (\\theta)  | \\phi(x) \\rangle = \n",
    "|\\langle \\sigma' (\\theta)  | \\phi(\\mathbf{x}) \\rangle|^2,\n",
    "\\tag{12}\n",
    "$$\n",
    "\n",
    "where $| \\sigma'(\\theta) \\rangle = U^\\dagger_{\\rm QNN}(\\theta) | \\sigma \\rangle$. From Eq. (12), QNN together with a measurement can also be seen as a parameterized measurement operator, which is used to compute the inner product with the data encoding state in the Hilbert space, which is, the kernel function. This is why we mentioned in the introduction that the mathematical form of parameterized quantum circuits is closely related to kernel methods."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "adequate-association",
   "metadata": {},
   "source": [
    "## Kernel-based Classification with Paddle Quantum\n",
    "\n",
    "> It is required to have [`sklearn`](https://scikit-learn.org/stable/install.html) packages installed for the support vector machine. Readers may run the following block to install the relevant packages:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "id": "automatic-timeline",
   "metadata": {},
   "outputs": [],
   "source": [
    "from IPython.display import clear_output\n",
    "\n",
    "!pip install scikit-learn\n",
    "clear_output()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "existing-devon",
   "metadata": {},
   "source": [
    "In this tutorial, we will demonstrate how to classify data using a support vector machine with a kernel computed by Paddle Quantum."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "literary-feature",
   "metadata": {},
   "outputs": [],
   "source": [
    "import time\n",
    "import matplotlib\n",
    "import numpy as np\n",
    "import paddle\n",
    "from numpy import pi as PI\n",
    "from matplotlib import pyplot as plt\n",
    "\n",
    "from paddle import matmul, transpose\n",
    "from paddle_quantum.circuit import UAnsatz\n",
    "\n",
    "import sklearn\n",
    "from sklearn import svm\n",
    "from sklearn.datasets import fetch_openml, make_moons, make_circles\n",
    "from sklearn.model_selection import train_test_split\n",
    "\n",
    "from IPython.display import clear_output\n",
    "from tqdm import tqdm"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "imperial-license",
   "metadata": {},
   "source": [
    "For the training and testing set, we generate some 2D circle data that has 2 classes."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "id": "literary-district",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Let's first see our training and testing set:\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 720x288 with 2 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "# Generate data set\n",
    "X_train, y_train = make_circles(10, noise=0.05, factor=0.2)\n",
    "X_test, y_test = make_circles(10, noise=0.05, factor=0.2)\n",
    "\n",
    "# Visualize respectively the training and testing set\n",
    "fig, ax = plt.subplots(1, 2, figsize=[10, 4])\n",
    "ax[0].scatter(X_train[:,0], X_train[:,1], \n",
    "              marker='o', c = matplotlib.cm.coolwarm(np.array(y_train, dtype=np.float32)))\n",
    "ax[0].set_title('Train')\n",
    "ax[1].set_title('Test')\n",
    "ax[1].scatter(X_test[:,0], X_test[:,1], marker='v', c = matplotlib.cm.coolwarm(np.array(y_test, dtype=np.float32)))\n",
    "\n",
    "print(\"Let's first see our training and testing set:\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "explicit-wayne",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Initialize the progress bar\n",
    "bar_format_string = '{l_bar}{bar}|[{elapsed}<{remaining}, ' '{rate_fmt}{postfix}]'\n",
    "pbar = tqdm(total=100, bar_format=bar_format_string)\n",
    "pbar.close()\n",
    "clear_output()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "asian-preliminary",
   "metadata": {},
   "source": [
    "Now, let's see how to implement a quantum kernel with Paddle Quantum:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "id": "ideal-jaguar",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Check if K(x, x) = 1? True\n"
     ]
    }
   ],
   "source": [
    "# Global variable for manual updates of the progress bar\n",
    "N = 1\n",
    "\n",
    "# The QKE circuit simulated by paddle quantm\n",
    "def q_kernel_estimator(x1, x2):\n",
    "    \n",
    "    # Transform data vectors into tensors\n",
    "    x1 = paddle.to_tensor(x1)\n",
    "    x2 = paddle.to_tensor(x2)\n",
    "    \n",
    "    # Create the circuit\n",
    "    cir = UAnsatz(2)\n",
    "    \n",
    "    # Add the encoding circuit for the first data vector\n",
    "    cir.iqp_encoding(x1, pattern=[[0, 1]])\n",
    "    \n",
    "    # Add inverse of the encoding circuit for the second data vector\n",
    "    cir.iqp_encoding(x2, pattern=[[0, 1]], invert=True)\n",
    "    \n",
    "    # Run the circuit with state vector mode\n",
    "    fin_state = cir.run_state_vector()\n",
    "    \n",
    "    # Update the progress bar\n",
    "    global N\n",
    "    pbar.update(100/N)\n",
    "    \n",
    "    # Return the probability of measuring 0...0 \n",
    "    return (fin_state[0].conj() * fin_state[0]).real().numpy()[0]\n",
    "\n",
    "# Define a kernel matrix function, for which the input should be two list of vectors\n",
    "# This is needed to customize the SVM kernel\n",
    "def q_kernel_matrix(X1, X2):\n",
    "    return np.array([[q_kernel_estimator(x1, x2) for x2 in X2] for x1 in X1])\n",
    "\n",
    "# Visualize the decision function, boundary, and margins of +- 0.2\n",
    "def visualize_decision_bound(clf):\n",
    "    \n",
    "    # Create a 10x10 mesh in the data plan \n",
    "    x_min, x_max = X_train[:,0].min(), X_train[:,0].max()\n",
    "    y_min, y_max = X_train[:,1].min(), X_train[:,1].max()\n",
    "    XX, YY = np.meshgrid(np.linspace(-1.2, 1.2, 10), \n",
    "                         np.linspace(-1.2, 1.2, 10))\n",
    "    \n",
    "    # Calculate the decision function value on the 10x10 mesh\n",
    "    Z = clf.decision_function(np.c_[XX.ravel(), YY.ravel()])\n",
    "    Z_qke = Z.reshape(XX.shape)\n",
    "    \n",
    "    # visualize the decision function and boundary\n",
    "    clear_output()\n",
    "    plt.contourf(XX, YY, Z_qke ,vmin=-1., vmax=1., levels=20,\n",
    "                 cmap=matplotlib.cm.coolwarm, alpha=1)\n",
    "    plt.scatter(X_train[:,0], X_train[:,1], \n",
    "                c = matplotlib.cm.coolwarm(np.array(y_train, dtype=np.float32)),\n",
    "               edgecolor='black')\n",
    "    plt.scatter(X_test[:,0], X_test[:,1], marker='v', \n",
    "                c = matplotlib.cm.coolwarm(np.array(y_test, dtype=np.float32)),\n",
    "               edgecolor='black')\n",
    "    plt.contour(XX, YY, Z_qke, colors=['k', 'k', 'k'], linestyles=['--', '-', '--'],\n",
    "                levels=[-.2, 0, .2])\n",
    "\n",
    "# To make sure we didn't make any mistake, check if the kernel function satisfies K(x, x)=1\n",
    "print('Check if K(x, x) = 1?',\n",
    "      bool(abs(q_kernel_estimator(np.array([1. ,1.]), np.array([1., 1.])) - 1) < 1e-8))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "close-description",
   "metadata": {},
   "source": [
    "Then, let's try to use a support vector machine with a quantum kernel (QKE-SVM) to classify our data:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "id": "driving-belize",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Let's see how the QKE-SVM performs on the training on both the training and testing data:\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 720x288 with 2 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "# Create the progress bar and the total kernel evaluation number N needed for training and prediction\n",
    "pbar = tqdm(total=100, \n",
    "            desc='Training and predicting with QKE-SVM', \n",
    "            bar_format=bar_format_string)\n",
    "N = len(X_train) ** 2 + len(X_train) ** 2 + len(X_train) * len(X_test)\n",
    "\n",
    "# Create a support vector machine with a quantum kernel\n",
    "svm_qke = svm.SVC(kernel=q_kernel_matrix)\n",
    "\n",
    "# Train the svm with training data\n",
    "svm_qke.fit(X_train, y_train)\n",
    "\n",
    "# See how the svm classifies the training and testing data\n",
    "predict_svm_qke_train = svm_qke.predict(X_train)\n",
    "predict_svm_qke_test = svm_qke.predict(X_test)\n",
    "\n",
    "# Calculate the accuracy\n",
    "accuracy_train = np.array(predict_svm_qke_train == y_train, dtype=int).sum()/len(y_train)\n",
    "accuracy_test = np.array(predict_svm_qke_test == y_test, dtype=int).sum()/len(y_test)\n",
    "\n",
    "# Visualize the result\n",
    "pbar.close()\n",
    "clear_output()\n",
    "fig, ax = plt.subplots(1, 2, figsize=[10, 4])\n",
    "ax[0].scatter(X_train[:,0], X_train[:,1], marker='o', \n",
    "              c = matplotlib.cm.coolwarm(np.array(predict_svm_qke_train, dtype=np.float32)))\n",
    "ax[0].set_title('Prediction on training set, accuracy={:.2f}'.format(accuracy_train))\n",
    "ax[1].scatter(X_test[:,0], X_test[:,1], marker='v', \n",
    "              c = matplotlib.cm.coolwarm(np.array(predict_svm_qke_test, dtype=np.float32)))\n",
    "ax[1].set_title('Prediction on testing set, accuracy={:.2f}'.format(accuracy_test))\n",
    "print(\"Let's see how the QKE-SVM performs on the training on both the training and testing data:\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "radio-freeze",
   "metadata": {},
   "source": [
    "We can also visualize the decision function, also the decision boundary with margins of $\\pm 0.2$:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "id": "dynamic-colonial",
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Calculating the decision function of QKE-SVM: 100%|██████████████████████████████████████████▉|[01:24<00:00,  1.18it/s]\n"
     ]
    },
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAXwAAAD4CAYAAADvsV2wAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjQuMSwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/Z1A+gAAAACXBIWXMAAAsTAAALEwEAmpwYAAB+jklEQVR4nO2ddXgUVxeH34l7SAgQSIAQ3KE4lA+Ku7tbgeJaHIprcSnu7u6lSGmxFncCgQRPQjzZJDvfH5EGiOyszob9PU+eZHfv3HszO/PeM+eee64giiImmWSSSSZlfJkZugMmmWSSSSbpRybgm2SSSSZ9IzIB3ySTTDLpG5EJ+CaZZJJJ34hMwDfJJJNM+kZkYegOpCYrWxfRztHjs/fMzNQbn8zM1TzOTNDbcebm0o5Rt2/xx6p9KBo0q7U+qNyGkHEi0JSilk68lDaVGh6v4elXt32lGg3HxanXWXXa0ui4uPRPStC7Ox9FUcyS0meyBb6dowfVWu5N+NtWg3rUO9bW3kryMfYOahxjbyn5GDtb9Whpb6c+Ze3V/wqSZGutIUHSkb1VnE7rl5PCFeZ6aysyWrPROTxSs/bDI9S7biIipR8XHh6jVlvhYQrJx0SGSz8mURGhqZ/UHXNz+6b2mWyBnyh1ga3JICEV9ibQpyxdAx6+Lcgn15f/ty4HgOTfozrwT34NqQP/5NevFPgn3i9SwJ94X0oFv72DlWToJ3JGHfDbOdqmCf3UJFvgm5mZ6R32JtAnHCdjyH+rgE9PKZ0XXQwCid+vulZ/4rWlrtWfeE3LEfyJPNAX+BM5JwX8sgW+OjJZ9RnTmjdBXj3p8ilADuCX6urRJ/jVcfHY2lupbe2DauDPMMD/1q36jAT6jAx4O6vYr96LUOjnNtTFAGBId4861j7E31tS/ftSwa9vax9Uc/MYPfD1ZdWbQP+5tAl6fQA+JdDKRYYaBLTtBjKU1a8vNw/IH/zp8dCogW+y6o3XR/+tQz49fdl3QzwFqAt/bYEfpMFf3+CXs5snNRkt8OUKexPoU2nbBHiNZIinAE3hr6m7B9Sz+uU6sWsIN8+XMjrgm0AvXYYCvQnyIIoiMTEKYhTRST9WNrY4Z8qMUqnE5/EdcnkXwsrKWnLd+nwKSPwuDW31ZxTwG8raNyrgf6uw1zfo5Qx5dQEfHhaC77OHKBTRWNvYULh4OQD+unCcoID3CTBWEBOjwC1rDmo3agfAxhXT+fj+TcJn8cAuUKQ0nXqPAmBknyYEfnxHjCKa2Jj4MpV/aMTQ8YsAqF/ejeiozynVpO2PDB2/CFGp5MfWlbC0tCJ/4VIUKVmBoiUrUKJMFVzdsml8bnQxAGgL/KDZJK9U8Osrokfu1r5RAF+uE7NytOozmjWvqQV/aNdqzh7dxb3bV4iLja8rf+GSrNr1FwDrl07lyYObnx1Tosz3ScD/+8IJ3r15hZWVNZZW1lhaWpPF3TOpbCYXN6ytbbCwtEooY0WBIqWTPu/cZzQAlpbxn1laWuGVrwgA5hYWTJy7mUf3/+H+rSsc3LmKPZuX8NOImbTpOphPgR84c3QnRUqWJ3/hUlhaSrs+dekGMrSvXyr4NYnoAdXBL3c3jyDXHa9c3UuIdbsckaVVbwJ9snZ1AHp1If/hrR/X/jrL3X//YsQvyzEzM2P+lIE8uvcPZSvXpFipitjY2uPolIl8hUoC8P6tH0qlEisrKywtrZPAbW6hfVvIxiLlmzMqNv7ai4lR8PThLdyy5iBLNg/+unCcsf1bAmBlbUOBIqUpWrICzdr3xT1HLq30SZtPAZqGeWqSwkFqZI866Rp0napBHTcPfA39dROz3hBFsWxKZWULfDePUmLTvqfVOlZXVr0J9Mna1SLoNbHinz+9z7F9G7l2+Qy+zx4AkDmLO8u3XSCruydKpRIzM7NUYStXJQ4CH975c//WVe7dusL9W1d4fP9f1u67Rk6v/Pxxch8Xzx6iaMkKFC1VgbwFimNhKf0a/VLaGAQMAX91FnHpA/xS0zRoCv60gG8ULh1V9S1Z9cYOenUgL4oiPo/vcu3yGSp8X4c8+Yvy9rUvB3euomSZ72nQvAtlK9UkT/6iCIJgdJBPrsS+5/TIQk6PhlSr0xwAhSI6ybXzKegDt29c4vfjuwCwtrGlULGyzF11GEtLK2JiFJLdQPD5d6Mu/A0xySvXiV19TuqmJ60AXxCEdUAj4L0oisVS+FwAFgENgAigmyiK/2ij7USZrPr0pS7otQF5da14RXQU508f4PpfZ7l++QyBH98BYGVlQ578RSlbqSaH/3yNtY1tMsCrl/FQzkr832wsBBL/v2bt+tCsXR/ev/Xj3s0r3Lv1Nx/fv0mC/C/DOvLi2QOKlqxAkZLlKVqyAt75i0lyVyV+b4YGP6gOfzmDX9e+/fSkFZeOIAj/A8KATakAvwEwkHjgVwAWiaJYIa06VXXpyMmqN4H+P6kNeEU0927+TYwimvLf10ERHUWT7z2wtrGjbKUalKtcizKVapAlW/xeCcZsxWtbiW6gRB3evZZrl89w7+bfSQNl6QrVmb/mGAC3b/xJbu+COLu4qdyGMbp79OHqkZObZ9nwTLp16YiieEEQBK80ijQlfjAQgb8FQcgkCEJ2URTfaNKunCJw5Oa+MZTbRh3Q+/k+5cqlU1y/fIab1y4SFRlOoWJlKP99HaysbViz5wo5cnp/4Ys3gf5LfTn4tW7fmcateyKKIu9ev+TerStYW9sA8QPriB8bEhOjwDN3voSQ0PKUqVQTj5zeqbYhF3ePPlw9GcHN86X05cP3AF4le+2X8N5nwBcEoTfQG8De2ZPUZLLqU5cxgD40OIj7t69SoWpdAFYtGM/Fs4fwzJ2Pek07Ua5KLUqV+x8QD7F8eXMB8l5gJVclDgJeubPjlbtZ0lOAuZk5c1cd4f6tK9y7dYWrl05x6tBWfhw8hQ69RqBQROP77AH5C5dKtW5tuXtAOvz14ePPiG4erUXpJFj4R1Jx6RwBZomieCnh9VlglCiK11OrLzWXjlysehPo46UK6ONiY3lw9zrX/jzN9ctneXj3Okqlkl2nH5PF3ZMXzx5gbW1Ldk8vIGO6aezMo9P8PCJO+krb5OrftTnPnz366n0n50zsOHo5zWOjYq0QRZHXfs+xtbXD1c2d00d2MGNMD4qWrEDTdn2oVqe5SquBNXX5qGv1m9w8/0nnLh0V5A/kTPbaM+E9lfWtWPUZBfRv/X2xc3DEydmV00e2M3tCH8zMzChUrCydeo+ibOVauLq5A1CoYN6Eo3QH+vSAa2h92T+pA0Bu7/y8fmuFR77uSe+98z2AR86wdI9NHGDz5ol/qo6KhUr/q0f/n+dwcOcqZozpwYq5o2nQsitd+o5NE/yGmuSVavHrY2JXjm4efVn4DYEB/Ddpu1gUxfJp1ZfcwjdZ9V/LEKBPD/JxcXFcOnuI7et+5dG9fxgyfiFN2/YmKOA9t2/8SekK1XBydtWbBS93yEtVWoPAG7+XtG9chRLfb8DKJjNxcVHcvtiJlVsOkK/gV7ek6m0qLLjx9+8c2L6Sd29esnr33wiCgJ/vUzxy5SU+AC/t4zWVOla/sVv8mlj7aVn42orS2Q5UB9yAd8AkwBJAFMXfEsIylwL1iA/L7J6WOwf+A74cwi3lBHrQf9RNeqAXRZFj+zawY/2CJBA0bdubqjWb4O6RG9CPmyajAT49JQ4Ah/duYcncX1Ao4nDJWo28xYfw+vkusmd5ya8rtmilrahYKxSKaKysrIkID6V1zXy4Zc1B07a9qdu0I/YOTun31wDuHrmBX5dunkTo6xz4ulDWnKXFNkP/UKmssVr1+gC9Lt02cXFxmJvH34RDe9QjPCyEDj1HULVWU+yt9ZAp8xsDfEq68tdFhg8cQN5S07Gwcubf890pVXUVty/1Yd2uYxpZ96kpJELk3Ik9HNixkod3rmNr50Dtxu1p331Y0gCflvQNfn2s2pWTtT+nj13GBb5cfPVyc9/oEvSxMTEc27+B7evms3jDabK4exIaHISDUyZsLXW76MkE+c/V/8duvA0qRrZcDQHwubuEwHeXiIsN5/jvf+Lglj6A1VVUrBUP717nwPZV/H5iN8u2nCN/4VIooqOwSgj/TEvfOvh1Ze2nBXz1sxXJQLp04egK9va28oW9nVVsmrAXRZFLZw/Ro0U5FkwdTNZsnkRGhAOQJbO9zmBvZx6d9GPS53r39i029v/FQ3jka09sbDh2Di4EBHz47Nxp+/zZWCgoVaoEo6evYt+550khnL9OGcigrrX468Jx0jIoE683dRfpSb3Oba2Vku8nqU/hUlggmTNqrPr/UkYLfDn46+3tzGTlwrG3ilML9qrcdLExMQzpXpcJQ9ohCALTFu9i4YZTFCiQRyf+eRPkVVPZCuUJ/ngp6bW1jRvFKy0mLiaUPN75viqviwHAxkKBm6td0usiJcrx/s0rxvZvSa+WFTh9ZEdSaurUpC741bnm1YG+lHtXKhekQl8T8Btd8jS5+OvlBnp1ld5NFvjxHa5u2bCwtKRoyQrUatiWBs27Ym+jRNs5a+QOdxuzKJ23EaVM3xWSXN179eXEkXq8fGSGS9ZqRIb78e7FBvoPHomNTfoXnqbhoMmVOPC37diNhi268/uJ3WxfN58ZY3rw6vkjegyclH5/1AzrlBrOqa+FW7oM4ZTq2wcj8+HLwV8vpwgcXYI+KOA9m36byZE961iy+SyFiv3nEtSmRa8vyOsD1rqQKgPA2zf+rF25jKt//41b1qx06d6Daj/U0bhtTReDQTy4/75wnHyFSpLV3ZPbN/7k1vWLNGvXB0dnF5WOlyq5RfPoe8FWWj58o7Hw5eLCkSJd+up1FWIZGRHOns1L2L5uPtHRkTRq1YOs7vE+Ym2BXh+QN1bAf6kv/4+UBgD37B6M+2WG1ttO/J40Ab+dVSw1atVOSulw4+/f2fTbTLavm0+jVj1o3XnAZzuIpXQ8SAO/Oou3dJmfR50FW7raWtEoLHxjg70crXqVUiDExdG92Xe8evGEqjWb0GvwFHLlKaAV0JsgrxtJdQFpIm1Y/FGxVjx7dIcd6xfw+4ndmAlmtO4yiN5Dp6rWBz1Y/MZu7RuthS8Hf72xW/WqLJq6df0iJctWxdzcnE69R5HdMw/FS1dKAL36sDdBXvdS5QlAW9KGxW9joaBo0YKMm7WOHgMmsmvjoqQN2+NiY3n66BYFi5ZJvQ9qWvxSrX3QTZoGfVj7aUm2Fr577u/EruP+VKmsHPz1cpyYTQ/2D+5cY+X88dy6fpHpS3ZTuXp8LLcmFr0J8vKSrp8ANLX6k+fwP3tsF9NGdaN0hep06DGcMpVqpJm6wWTtp6xJnSwzZhw+6C6+XlewlxoLrE7YWXohbv6vfJgysgv9OlTD1+chg8ctoHyVOthYKGQLexuzqKQfk1RX8vOmi3OnaXhn8muuUrX6/DRiJq+eP2Jkn8b0aVuZcyf2olSmfL+oE8op9X6SfL9KCOHUZfhmajJqC9/Q/nq5WfWqXPxKpZIujUsS8OENrbsMol33odjZO8oS9BkV7qIoolBEExkZhSiKuLikH62iK2n7CUAbfv6QCJEzR3ewY918zMzMWbf/OmZm6d+TUi1+XUfzGMraT8vCN1rgG9pfL6eJ2fRAHx0VyeE962jSuidW1jbcu3mFbDly4pY1h+xAb0jIx8bGEhUZSWRUJFFRUURFRhEVHRX/XmQk0dFRREZGfvZ+VFRUfPnIyIT3opLKRkeGExUVnfB5VELZ+N/J7ztPTw/KlqtI2bLlKFu+Al5eedLNQqkraWsA0Ab4w6PNCfjwhqzunoSFBjOmfws69hpJxf/VS71dI3bzaAv6aQFf1pO2KcnQ/no5WfWqJDc7fXgb65ZO4cM7f7Jk86Ba7WYULVVBowlZrS/R1yHkRVHk4YP7nD51kjt3bhEVERYP86joeHhHRydAPorYdFaDpiYbGxtsbW2wsU74bWOLjY01tra2uGTKhLWNDbY2NknlbG1ssbaxxtbGltjYGP69eYuL589xYP9eANwyZ6ZM2fKULV+BsmXLUbBQ4aQkdbpW8u9CE/hrY4LX3joOe8+sRMXCx/evCQ4KYEz/FnxfozH9R83FPUeur9vVQxinOpO6uprQBWmRPEZl4WdkF442rXpRFLn252lWzh+Pz5O7FCpWhj7DZlCqXFXZWPS6hHxcXBz//vsPZ06d4PSp4/j5+cdvvlKwII6ODtja2mJjHQ9km2QgTgnYiaC2Sfa5bbLPra2ttWKNi6KIz/PnXL12nWvXb3Dl2jX8/V8D4OjgQJky31GmXCXKlCtH8WIlsLLW3IJWVdqw+rVh8YdGwu6Ni9m8ahaiKNK5z2jadR+W5mAoJzePvlw8GcKlY0wuHEP76kVRpH+n6gQHfqTX4ClUr9tCo8RmWsu5okPIKxQK/v7rMmdOn+Ts6ZN8DAjAytKSKpUrU7dOLWrVrIFb5sw6a18X8n/9mmvXbnD1evwg8OTpUwCsra0pVbIEZcpXomzZ8pQq/R329vY6749c3D2+r96xbPZIoqIimL3ioE42YdGlm0dX4E+EvtED35CwNxYXzlt/XzatnMmPg6fgkjkr79/64ZI5K44S+/9ZexqCXtf++PDwcC5e+IPTp09y/vezhIaFYW9vR/Vq1ahbuxY/VKuGo6ODTvugTwUGBnHtxg2uXrvGtes3uHvvPkqlEnNzc4oVLUKZchUpU7Y8ZcqW0/lEsKGt/qhYK6KjIrG2seWtvy9rl0ym95Apaa7a1bW1LwfoA4xsaW6cwO8346qkYwwJe0NZ9SHBgWxdPZf921YgmJkxad5mg8fT6xL0QUFBnPv9DGdPHePipT+Jjo7G1cWFWjVrULd2LapUqYyNHt0dhlRYWBj//HuTq9euc/X6dW7euo1CEf+dF8ifnzLlKlC2XHnKli2Pe/bsOumDHMD/x8l9zBzXCzMzc7r1G0fLjv2xsEzdSMzo4DdK4Ht4lxH7TL2iUllD++sNZdVfPHuQXycPJORTAHWbdqJH/wlkcffMcKB/++ZNgqvmOFeuXiMuLo4c2bNTp3Yt6tapRbkyZbCwMLr4A60rKjqa27fvcO36da5ev8GNG/8QFh6/X0FOT0/Klq9ImbLlKFuuvNYjgQwNfp/n/iyZNZy/L5zAK18RBo9dQKlyVVNvS8duHkNCP0MD35j89dr21f8yrCOv/Z7z89TfyFewRIYC/fPnPpw+eYIzp45z6/ZtAPJ6e1Ovbm3q1q5F8WLFDBa6aCyKjY3l4aNHXLl6PX4QuHadwKAgANzc3ChTtjzlysc/ARQoWEgrkUCGBH9UrBV/njvCklkjqPB9HYZOWJx+WxnQ2s+wwM+oLpy0QH/r+iVc3bKR0ys/4WEhWFnbGMxPr03Qi6LI/Xt3OXXqBGdPnUiaoCxRvBh169Smbu3a5MvrrbX2vkWJosgzn+dJcwBXr13H/3VCJJCjI2W/+47vyleiXLnylCxVWqXFTqnJkOD/FBpLXFws9g5O3L91lQd3r9OsbW/M03gK1CX49Q39DAd8Y3LhaMuqVyiiWbdkMrs2LqJ63ZZMnLsJUN9PL4cJ2bi4OP65cT0e8qdP4O//GjMzM8qXK0u9OrWpU7sWOXTke5Yim5gwvbYXZam/iWY/f/8k+F+9dp1nPj4AeHvnoXuPPjRt3hxrFfanTU2GjOyJirVi6eyR7N2yjHyFSjBk3CKKlqqQehtG6OZJCfoZCviGhL2hrPpnj+4wY0xPfJ7cpXHrnvw0YiYuTtIyiSa1Y2DQK6Kj+euvPzl18gTnzp4mIDAQKysrqlapTN06talVowaurtqNMNE3sLUtfQ4AHwMCuHjpT9au38Dde/dxc3Ojc5futO/YGWdnZ43qNoTVHxljyYXTB1g6eyQf37+mfvMu9B4ylUyuWVJvw8it/QwDfEP66w3lq7/x9zlG/9QMR2cXRk5ZQaX/1TeIVa8J6MPCwrhw/g/OnD7J+XNnCQsPx8Henh+qV6Ne3TpUq/o9Dg7ahZqxQz4t6WMAEEWRv/6+wm+r13Dh4iXs7Oxo3aY9Xbv3wMMj9dBHVaQp+NWx9oNCFGz6bRa7Ny+m95CptOk6OP12ZAB+daCfIYBvLP56bcFeqVRiZmZGdFQkaxZNolPvn8mWxUlS3UltGAD0gYGB/H72NL+fOsbFPy+jUCjI7OpK7Vo1qVu7FpUrVcLaWr2nlFT7moEhn550OQg8ePiI1WvXcejIUURRpH7DRvTq1YfCRYpqVK8hwP/48XOy58yDpaUV1y6fwdEp02fbd37VhgygD9LA36++YNzANxTsDTkxu3zuKBauP4mtXfyNrI5VbwjQR0VFMXf2DHZs30psbCweHjmoW7s29erUpsx3pbWeE+Zbhnxa0sUA8PrNG9Zt2Mj2nbsID4+gQb26DBs1npw5v85pI0X6Bn9UrBWiKNK33fc8eXCTjr1G0q3feINM6uoC+kYN/Ixo2acF+z/PHWHKyC5k9/Di1zVHyZwlu9HA/snjxwwf0o9Hj5/QsX072rdtTdEiRXQSPmkCverSNvyDQ0JYt2Ejq9asIy42lq7de9H3p/44ODpqVK8m4FcH+mGhwSyb8zMnDmym+HeVGT97A1kNtFJXmy4eowX+0HnXVCprSNhr019/4uAW5k76iQKFSzFr+X6cXdwkw94Qk7KiKLJ75w6mT/sFB3t7fp07i2pVU1/0oolMoNdM2oT/27fvmDN/Pvv2H8Qtc2YGDR1Bq9ZtNX6KUxf86kbynD6ygwVTB2FhYcmqXZdx98idehsygD6kDf60gC/bHa/MzFSzCjMK7E8e2srs8b0pXa4av645pnfYq7sjUkhIMMMH9WXC+NGU/e47jh0+oHXY28SEJf2YpJm0eS7d3bMxf85sDu3bTZ48XkwcP4YWTepx+c9LmvVRzSdMdXbfsrFQULtRO1btukyzdr3JlkLK5c/akLjLltTdtVSuV821N7IFviqSO+zj4uI4snMF/dpWpGeToiyeOZKggPcpli1T8QdadOzHjGV71dqByhAunJv//kPzJvU5efoMo0YMZ9P6NWTNknq4m+R+mSCvUyWHvybnuUTx4uzatoXlixcSHh5B964d6fdjV3x8nqnfNw22ZFQH+vny5qLHwEkIgoCf71MGd6uDn+/T1NswUugbLfDlDnuAxdP6s3PjOhwydyCb989c/fs1P3WoSXhYCBA/IBzatYa42FjcsuZg4Oh5ONkJkmCvyZ6i6t5USqWSVb8tp0O7VgDs2raFn/r8qNHKzM/69Y2A3koRhpVCPv+nJvAXBIEG9etx+sRRRo8cwZWr12jcoA7Tpv7Cp0+f1O+TmteoOvdE4n334Z0/L57ep3ebypw+vD31NiRY+3KBvmx9+DnzlRUHz0k5W6YcYB8dFcnGpROJivr6YsxbsDjfVarFgPaVKPW/rZhb2CV99uz2ZFq1b0jjNj2ZPro7F04fYMrC7VSt2dQorPoPH94zevhgLl2+TMMG9ZkxdTLOTuqFi37VJyODvK5grbCST0pndX3+HwMCmL9wMTt27cbR0ZH+A4fQoWNnLNPIYqlSf9Tw76szofv+rR/TRnXjzj+Xqde0E4PGLsDWLvU9B6T49nUdwZOWD9/oUgxKWVSlqtSx7M3MzPj92A7snMtj75gn6f2Pb86iiI7EKZMrLllKfgZ7AEeXCvxz9U8u/3GUf66co9/I2UYD+4sXzjN65FDCwsOZNX0qbVu30jgCx5CQl5N1nVzJ+2Vo+Cd+P1LB75Y5MzOmTqZLpw5MnzmbGdMms2PrRkaOnsAPNWqqfd3YmEVJhr6debQk6NtYKMjlmZUFa0+w8bcZbFk1m2w5ctGt3/jU27CKVRn69lZxKkFfylaKqm6jaFQuHUOuoP3ykczSypr2P44CZRDZ87Qge54WZPGsjSLKn469x5DTMwcRIc/58gkqIvQRD+/8xc3rFxg9fTWtuwzUG+zVfTxWKBTMmT2DXj26kDmzK4f37aFdm9YawV6fbptE18mXP8YgufRX3e+qUMGCbFq/lnWrfgNB4Kc+PenZtT0PHz5Qvy96cvHY2yjpMWAiizacpn2P4QB8Cvzw1T2d1IaB/fr2tulzz2iALyfYJ6p+i15Ehj0h7NMjAN767qXKDw3Jmzc3hUuUwy2rG68eryYuLgpRFAl4+ycf35whRhHN1IU7qNuko15hr45evXxJp3YtWLt6JR3bt+Pg3t3kz59PrbrAMKDPKDL0gKWJf7/GD9U5eeQQk8aP5e69+zRv0oCJ48fw8eMH9fqihvGibhRP8e8qY21jS2REOAO71OSX4R0JDQ5KuQ0ZTOamJaMAvhxhD2BlbUO7XqN4+2IzsTGhvH95gO79xwDxF/mc3/aQLUsQ/55rxT/nWhDybhOzlu1m5+lHVK7eUPawP3L4IM0a1+P5C19WLFnE9Cm/YGMj3Yeqz7BKuVjE+pCh/ld1v0tLS0u6d+3C+TMn6dq5E3v37KJuzWqsWrmC6Gj1rlF9WPs2FgpsLBRY29jSuHVP/jx3hB/bVOLezVSy+coY+rIHvlxhn6hEK//Z7TlU/qEhHjn/y9nu6paNuSv3Mn3JDiwtoUPPwZQq9z9s7Rz0Ant1XTgRERGMHT2S4UMHUbBgAY4d2k/9enWlt2+y5vUmQ1j/6n6/mTJlYtL4sZw8eoiKFcrz69xZNKhbg+PHjqbqLkmzH3py8dhZxdKm62CWbDqLmWDGoG612LlhYYp9lkMET0qSNfDlDnuIt/K79BlJ4LvLSdZ9ct34+xwTBrfD3sEpacs1fcFeHT18cJ9WzRqyb+9uBvzUl51bN+Pp4SGtbRPoDS59wl/d7zuvtzdrVq5g68b1ONjbM2RQPzq3b8nt27ek90GPLp7CxcuxavdfVK3RhItnDxEbG5N6GxKgrypzbK2VaoNfK2GZgiDUAxYB5sAaURRnffF5N2Au4J/w1lJRFNekVWfOfGXFsUuvq9S+oWAP8V+oQhHNg9vXKFn2+88+O3/6ANNHdcMzd37mrDyIW9YcOoe9uqAXRZFtWzYxa+Y0MmVyZuG8uVSuVFFyPfoEvUnSpeuoH3XDOOPi4ti1Zy+/LljEx4AAmjZrwbDhP6u1+bo+QjchPtd+ZEQYdvaOhIV8QikqcXJ2Tbl+HYRtQsoRPF2r6zCXjiAI5sBjoDbgB1wD2ouieD9ZmW5AWVEUB6hab+4CZcXRi9MHvqFhn5r8fJ/StWlpChcvx8yle3F0dpEt7D99+sSEMcM5dfoMP1SrxrzZM8mcOeULN9W29eSfN0m70tUAoC74Q0PDWL5yJWvXb8TMzIxeP/al5499sLOzS//g5O3rKR9PVGx8iu/R/Zrj//IZM5ftwzN3ykEN+oJ+WsDXhkunPPBUFEUfURQVwA6gqRbqTVdyhT2AZ+58TJy7mbkrD0uGvVqPmmrC/vq1qzRvXI9zf5xn/NjRrF21QnawN7ltdCdduX7UdfM4OjowasRwzp44Rs0aP7B0yULq167Ogf17USpVd2Poa4Vu4n3dsddIQoKD6N+xOjevXUy5bhlM5moD+B7Aq2Sv/RLe+1ItBUG4LQjCHkEQcqZUkSAIvQVBuC4IwvWw4LTDteQIe6VSyeqFE7l1PT55VLXazbC1s5cMeylS98KOi4tj6ZJFdO7YFisrK/bt2k6v7t0kp0fQJexNoNevdAF/dcGfM6cnyxYtYPf2rWTNmoVRI4fRvXNb3r17J619PUG/XPmyLN92nkyuWRjZuxEnDmxOuW4DQ19fk7aHAS9RFEsAp4GNKRUSRXGVKIplRVEs6+CcehIuOcI+LjaWORP6sm3tPK5eOgX8F86lct16surfvnlD985tWbJoPk0bN+LIgb0UL1ZMWts6mpjNqGGVForwNH/kJrmAv1zZMhzYs4tZ06dy6/Ydmjeux8UL56W1rSb0pd6PefN4snTz7xQvU4V1S6cQGZHy/ys1gkfKZG560oYPvxLwiyiKdRNejwEQRXFmKuXNgUBRFNPcETk1H74h96BN7UuKjopkysguXP7jKN36jadL3zHYWqY+c59i3XqC/bnfzzJm1DCioxVM/WUiLZs3k1yHrkBvDNIXnGOtUs/bYghp09evrn//6dNn9B88hEePn/Bj758YPHS45Nw8+pjQDYsU+PDOn+yeXsTFxhIbG4O1Tcrg0oVfv02l1Pe01YaFfw3ILwhCHkEQrIB2wKHkBQRBSD7V3gRQa121HGEfGRHOqJ+a8df5Ywwet4CuP42VJewV0dFMnzaZvr17kN09O4f375EF7A1lzadncRvaEpfbE4A2vyd1rf18+fJycO9u2rdtw+pVK+jSoRWvX/unf2DytvXg4nGwFcnu6QXAil/HMKRHXQI/vk25bh25eFKTxsAXRTEWGACcJB7ku0RRvCcIwhRBEJokFBskCMI9QRBuAYOAblLbkSPsAaxtbMmWIxfjZq2nWbs+sozEef7ch3atm7Fpwzq6denM/t07yevtnf6BydvVogtH324bOblQIqOi8X/3kTuPfYiLi7/+VHnKlkPfwfDgt7GxYea0KSxe8CuPHz+hWeP6nDl9SlodenDxJHKgVNmqvHh6n34dquHz+G7KdesR+rJNj5zcpSNH2L/190UwMyNb9v/mn+UI+wP79zJ50nisra2YO3MGtWrWkFyHNkGvT+kSjnFxcQiCgJmZGW8+BHDz4TMCg0MICg6N/x0Sxrg+nXBzcWbjgZPMWrONwOBQIqP/+86fndhKFtdMzF67neMXr1Kz4nfUqvgd5YoVwsJC9bA8Q7l/tB3SKdXV88LXlwGDh3L33n26dOvByJGjsbKWGFapYxdPVKwVj+//y7iBrYgID2PSvM2U/75OyvVqyb2TlktH9sCXI+yfP7nHz32bkC17LpZs/h1BkLZpCege9mFhYUyeNJ5DB/dToXw5Fv06D3f3bNLaNELQqwP5mNhY3n4MJCgklMBPoQQmQLtOlXLkyp6VK7cfMHf9joT3QwkKDuVTaBin18yjfPFCbDl8mn5TFybVZ25uhouTI8dWzKKQdy5O/3Wdfacv4ursiKuzU9Lv2pXLYGdjw9Yjp1m//wTX7z1GqVTiZG9H/f9VYPXkEWqdA30PAIb070dHK5g5Zy4bNm2meLGizF+0gly5U9+TNsU29eDXf+X3nrEDW/H61XO2nbiPc6bMqdetIvhTg77RAn/qatVW2oL2I3JSg/29m1cY078FVtbWzF15mDz5i8oO9nfv3mH44P68fPWKwQP6M6BfX8kbS2sKezlZ87GxcRy7+De///0vAcEhCZZ4GOP6dKRhtUpc+ucODfqO/uq4LbPH0uSHKlz+9y6jF6zCJQHWLk6OuDo70rlxHXLnyMaHwE/4vnmXBHMnezu1dv8KCgnl/LVb/H7lH0QRlowbBECX0TPImtmFmhXLULVMcRzsVN/ZR5/wNyT4T54+w8jRYxGVSqZMn02Dho2ktaeHhVpBIQqePLhFiTJVgHhXXmopxjWx9o0S+HkKlhUnr1IN+PqC/fMn9+jXsRqZs2Rn7srDZPf0kh3sz58/R/++P+KWOTOL5s+jfLkUv/e02zQi2Kti0T/x9aNM6z5kcrQnm5srrk7xYO7TpjHVy5fiQ+Anjl24Eg9zZ8ckCzxzJicsLQy7R1BMbCwdRk7jwvXbREZHY2lhQaNqFRnevQ0lCuSVXJ8+BgBDgd/P35+BQ4bx781bDBg4hIGDh0pvTw8uHoCje9fH59mas1Hr0E8L+Ea349WX0kWsfWrasnoulpbWLN54Glc3d9nB/sOH94weMZS8eb3ZvmkDLi4uko6HjAX7Z69ekzdnDvLn9uTEytlUKFE4xSedLK6Z6NpMejZQfcjSwoLdC34hWhHDXzfvceLSVbYeOcMPFUpTokBeYmJjMTczU/mJIvGc6RL8VoowrUHfJiZMZeh7eniwa9sWxoyfyNIlC3F3d6d12/bS2tPxjlo2FgqiYq0I+RTIuRN7KFKiPK06p5xxRhe7aBm9ha8v6x4gMiKM50/uU6RkeUBek7RKpZI+PTtz5eo1juzfq9YmJcYC+/RAL4oiizbv5ZflG9mz4BdqVSqjl37pSyFhEVhbWWJtZclvOw+xZu9RBnZoQdv6P2BjbSWpLl2C31CWfkxMDD37/MSfl/9i1ZoNfF/1f9La0oOVL4oiE4e0468Lx1m0/jRFS1VIuV41rHxdx+EbTPq07pVKJbZ2DrKEPcCmjeu5cPES48eM1mhHKrkrPdhHK2LoN3UhE5eup1mNKlQuXVRPPdOfnBzssLaKX3CUO4c7NlZWDJyxmGJNuzN33Q4CPoWoXJcuQz21vVJXVVlaWrJ88UIK5M/P4AF9efjgfvoHJW9Lx7H6NhYKBEFg1NSVZM3myeQRnQgO+phyvVoO2TRq4GtbqZ3cuzf/plvT0jx/Ku3C0ZcePrjPr3NmUqtmDTp1aKdWHcZg3acHpo9BwTTpP46tR84w5seOrJ8+Cjs1dugyJtWvWp6LmxdzaOl0ShTMy9TfNtNj/GzJ9egK/IaCvoODA+tW/YaDgwN9enXj3duUFz6l2pYeoO/glIlJv24h+FMAV/88k3q9WoS+0bp09JknZ/RPzXhw9wY7Tj6UnAwNdGvdR0VF0apZQz4FB3Pi8EHJmS4hY8AeYOuR0wydvZwVE4fSsra0x/iMontPXxCtiOG7Ivl5HxDEqAWr6N++GWWLFpRUj7ZdPYZy79x/8JA27TuSM2dOtmzfg4Ojo7S29ODe+fj+NW5Zc6Rfr4runYZlrDKmS0ebSg32j+79w5VLp2jdZSC2drqPcJBqWcyZNZ0nT58yf84stWBvDEoP9okujI6NanN918pvFvYARfN58V2R/ADcefKcM5dvUKP7MOr3GcXxi1dUTjGsbWtf2yt0VVWRwoVYtmQhj588YeigvsTESEt7om7OKilKhP2/V88nZdrVlYwS+Pr03W9dPQcHx0w0b98X0M/2hKrq4YP7bNu6mW5dOlP1+ypq1SF36z4t8IiiyNJt+ynZvCcPnvkCkCt7Vp32x5hUs+J33D+8gRlDeuH7+h1th0+hUocBREWrdg3rws1jCOhXq1qVaZMnceHiJab8MkHyvrnqbJ2oct0JPImLi2PRjGFMHtFJK3l3UpNRAl/bSu1Evnj2gItnD9Gi40/YOzjJypUD8Ouc6Tg5OTF0kMobiX3enoxhnx5sFDExDJ65hLEL11C9fCly5ZC2ilgOMo8MwzxStwOmo70dAzo059b+NayZMpL6VcsnRfLsPX1BpQnejAD99m3b0K9vb3bt3M7qlSukt6Vj6JubmzNp7iYiwkOZ+nM34mJTZpKm0De6OHx9Wvc5vQowYc5GylSSnn9G17r85yUuXLzEuNE/4+ycZqbpFCV32KelgE8hdB49g0v/3GFE97aM79NJrZWt+lJ6UE/8PM5Wd/vNWlpY0KZe9aTXr99/pOeEudhYWdKpcW36d2hGHo/U94+1UIRr1a+vzVh9VTVi6BD8/Pz5dd5sPDw9adioSfoHJZPUGH2p8fl58hdlyPhFzB7fmw3Lp9Fz0C8p1yshPv9LGd2krT7j7pNLTta9UqlMmKj9xNmTx7GRmDAK5At8VazJaSs3s2jzXpaOH0zbej/opB/qSJvWui7hn6j7z16wZOt+dp34gzilkqY/VGbqoJ5pusXkOJkrZRI3OlpB5249uHnrFus3b6ds2XLS25MAfXVW4c6Z2Jfj+zexfNt5ChdPuX9pAT+tSVujAr4+I3NWzBtD5izZadM1Pp+JnIB/+NABRgwbzIJ5c2jeVJqVAsYL+6hoBTbWVsTExvLQ5yXFC0hL8awt6doNk1z6AP/r9x9Zuesw246e5a9ty3BzSfuJ0dih/+nTJ1q0bU9gYCDbd+3H21taigqpkTtSoR8dFcmZYztp0LxrqmkXIHXom6J0UlFaqY/3bFnK+7fxW/XKCfaK6GgWzp9DkcKFadpYWoIoME7Yi6LIbzsPUbFDfz4GBWNpYaEX2Cf62L/80af00WaOrG5MHtCd+4c34ObiTLQihk6jpvPnPynnb5ejT1/KdZ0pUyY2rF6FuZk5fXp2JTAgQFpbOvbnW9vY0rBFNwRB4P1bP2JiUuaPOv58owG+Pn3329f9irmZOW27DdG4Lm1r29bN+Pn5M+bnEbL2W6uq9CZnY2JjGTprGT//upJCeXJKTh2giuQA9vSkj34lJooLCgnl4fOXNBs0nkPn/kyxrBzDNqVAP1eunKz+bTnv3r+nX5/uREVJg7g+IncCP76jV8sKrF44MfV6JULf+ImhplI7UR/e+XN8/ybqN+9Clmwe0uvVoXUfEhLMiuWLqVqlslphmHKz7tODRmBwKC0GTWTd/uMM7dKKbXPGS0oN/KWMAeyqSNf9dndz5eSquZQokJfOo2eyZs/RFMvJcWWulGv8u9KlWPTrXG7eus2oYQNUXqOQ1JaOY/Rd3bJRq2Fbdm9azMWzB1MtJwX6RgF8fVr3OzcsJE4ZR/sewwFp7hxdxtwDrF75G58+BTNqpPSNMYwN9gBjF67mr1v3WDFxKJMHdNfoicYYwZ6edAn+zJmcOLx8OnWrlGPYnOUs3bo/xXJyhL4U1atbh3FjRnHi1Gnmzp4h+Xgp0FfHyu87YiaFipVh9vg++L/ykdy/L2UUwNe20hoRq9VpwU/DZ+LuIW3XHHUk5WJ58/o1GzespXnTJhQrWkRaO1reeFxTpQeJREtr+uCeHF0xi46NaqndlrFa8VKkq6cVOxsbts0ZT9+2TahRsXSq5eS2QEvq9d6zW1e6du7IurWr2bp5o/T2dAh9KytrJs3bgpmZOZOHd0QRnXJbqlr5sge+lK0LtaHipSsl5afWpXUv9XFw8eL5iEolw4YMknScNqRNiys9MKzZc5TmgyagiIkhcyZnKpQorHZbGR30KUnb4LewMGfO8D4UyeuFKIpsPHCSiFT83cYKfUEQmDhuLLVq/MC0qb/w+9nUE5lpQ1Kh7+6RmzEzVuOVt0jSxvcp1qsC9GUPfFWladx9SHAgS2aN4MM7f212Syt69OghB/btpWuXTuT09JR0rFxcOelZgbGxcQyfu4Jhc5ZjZWmJIkazFYXfIuyTSxcW/82HTxk0cwlNB4wnMDg0xTLGCn1zc3MWL/iVYkWLMGzIAO7cuS2tLR378ytVa8DYmWuxtbNPMzVEetCXNfD1ad3v3bKMfVuXExbyCZCXdb9gzgwcHBzo37ePtHZkBPu09Ck0jJZDJ7F69xEGdWrBjnkTNJ6cNSle2nT3lC6cn40zRvPvgyfU7T0Sv3cfUixnrNC3s7NjzcoVuLq60PfH7vj7+0lrS8f+fAA/36f071QdX5+HkvqWKFkDX1Vpat2HhQazb+sKqtZsQp788tow48rff3Hu/Hn69elNpkyZDN0dyVLl5u8xfg6Xbtxh2fjBTBvUU/KG68klN9gHh0Xw6t1HyREgupA2wN+s5vfsXzyVN+8DqNVzOPefvUixnJzCNqVAP2uWLGxYvYro6Gj69OxKSEiwtLZ0DH1rG1ve+L3gl+GdiIyQfo5lC3x9hpgf3LmKsNBPdPzxZ0A+1r1SqWTe7GnkyJ6dbl06SWtHBta9qjf91IE9OLh0Gp2b1FG7LblNzoaER9B9wgIKNOtNlc7DKdayH0f/TH/LTn1I03NVtUwJTqyag5lgxgv/1DcW0dVOWupIyv2QP38+Vi5fwgtfXwb1+xGFQtrCSymSCv0s2TwYP2s9vs8esHD6EMmZP40uedqX0tS6j4wIZ/emJVSoWpeCRb/TZtc01onjR7l95y7zZs/ERsLOTcYA+w0HTnD/mS+zh/WmaD4vjdpSFV4fPoWw/cR5Xvi/o0zR/LT8oZJOFnIB9Jy4kNjbr1irzIWd0ow7nyL5acoSDi6eROmC8auEX7x5z/UHT1M8vma5Erg46jatQvLzJjWFQ7H8ebixeyW2NvFpA/zffcQjm9tX5Yw16VrlihWZPWMaw0aOYsK40cya82uaaQ6SS52N0FWVjYWCMpVq0PWnsWxYPp0SZarQsEU3lY83euBrquioCCpVq0+jlj0A+Vj3CoWCBfNmU6hgAUn5cuQQgpkW7OPi4hi3aC3LdxykVqUyKGJik/ZnVUeqwv7m4+c0HTKV7+KsyakwZ9WZayzYtJ9Tv03D1Um7APF9856/7jxkXVxOLIX4R9USgh3NYhxZvuMIqyfFR1od+ONvZq3eSRmb/3LXKIGL4QEcWziR/+lxP151MnYmwv7ijds0HzSB2cP60LNlg6/KyQX6NjFhknLutGjWlFev/FiweAmenjkZOHio6m1JgL6UrJqJ6tR7NHf++YuTB7dQv1kXldeoGDXwtZERM5NrFkZNXSm5bV0vstq7ZxcvX71iw9rVGvm0pUpT6z49y77vlAXsPH6Ofu2aMm1QTyws9OOvHzRjOZ0jHahp5gxm0CxaZNmHAOZs2MOsQd3U7kNK8nsfgIelLZZxn9+EuUUrTvm/S3rdrVFN5m7YS/soRzyE+CeNS8pQQnLnpGopaWsttCV1wF+maAFqVPiOobOXEadU0rv11zmejBX6gwb045WfH0uXLKRAwYLUrff1gJZqWzqCvo2FgiismDRvM9Y2tpIWJMrWh68PiaLI4/v/8sbvhaG78pVePPfB1taWalW/N3RXtKqzf/9D85rfM2tYb41gn5IioqKp3WccVToN/+ynQvshPHjhR3XBKamsIAg0iHPkyB9XtNoHgCLeOXmpiCBQ/NzQuG4RRfmShZJeZ3K0p1+bhuy2jN+ERCmK7LQOZUK/jiq7D+SgxAVaZYoWYOvh06mWk5NPX1UJgsCMqZPJkT07R48cNnR3PpOjswtW1jaEhXwiMkI14+ebBj7AoK61OLBDuoWva7m4uBIZGYlCIW0PTrmrdOH85MstbS2BqrK1tiI8IoqCfhF0fi0k/di8D0MJxPL5BFc0Sqwt1XcnpSYXRwf6tW7AZMv3XFOG4StGs5lArlor6Ne24Wdl+7dpyHUi8BcVXBbDcM7qQt0KpbTeJ6mSOqlrYWFO1e+Kc+/ZCxQS942Vu6ysrChVsgQP76ecPdSQ8n/5jMZVcnD+9AGVyhu1S0dVRSgsUnTrCIJAJtcsBAWmHE+cZp1x1jp167i4xm9IHhQUhLu78W3fl5r2Lpyss7oFQWBiv478PHk5HRU2mAkCH8QYHpsrKF8gP/sfB9IOFwBiRZHdlqG0baB+ZFBaGv9jO7xz5WDVjqMEhITyv7LFOdejNdndPt9oPtHK37XrHM8FBXP7DTAq6z65vitSgFzZs/H2Y5Cs9xaW6tYBKFq0CMdOnOTK33+hFL8OsXVxcaVQIfVXhUuVjYWCqFgr3D28sLK2weexaoPRNwH8tOTimoVPge8N3Y2v5OISD6bADAZ8XatuxdJMyeLM335hVBYc2WcRSrfGNRnQthGNBv7CjZC3eIlW3BQjKF08P0M6NNVJPwRBoGO9anSsVy3dsv3bNGTpziN4Z8sqC+teXTWr+T3NaurPBanPbRIT81f91Kc3ltaZsbH7b+COCHtPJmcrTp/9XS99SS5zc3Nyexfi+ZN7KpX/5oGfyTULH9+/NnQ3vpKLy38WfkbSnLU7+Pv2ffYtmqKT+pNb+fkUNpwnlMWdmpHVxZnr2xZx9vptXr79wNiC3nxXSNpOR7pSJkd7lozqg1eObEZr3asqbU/e6ktFi8QDv0zZMjzzNcer2Pikz57+O5JeP7ZI8/iIiHBe+78im3sOHB2dUiyjTrQOQN4Cxbj6Z+pzJ8ll1D78cIXmk34umbPySQ2Xjq7lmuDSCQgMNHBPtKsPQZ+4fle9ZeGqqm7F0jhkcWYKb+jWuCZZE7bsMzc3o06FUvRqWls2sE9Uq5pVKFs4n6G7obEmL99Im2G6c9sZSm6ZM+OeLRsODg6EBPxDRKgvACGBd4hT+NO8RasUj7MWIlm6cB41KpeiV5eu1Pq+DDMmjyc2VrNcUcmVJ38xAj++U4ljRg18bahp296MnLzC0N34ShnVwndxcuRTaHiaWf80VaKV/95cydBOzXTWjklfK1oRw7mr/xKjRaDJRcWKFuHJowf0/LEX7303A/DedxODBg/EyirlBXxbt2xm7+7DFK20hiKVNlDi+038fu4mSxfO1Vq/KlStw7CJS7CwTH8R4Tfv0pHb6tpEOTk7IwgCgUYG/Fgr+zTD71ycHQH4FBpO5kwpP9pqQ/UqfceD3ctw02EbulJAcChPXqXsZixdwFujhWpSZB4ZJnkFbqlC+YhWxPDo+SuK5c+jo55pLnUmbosUKczvf5ynVevWrF29hncvj6Zp3QOsX7cBj/xDsLaNn8S2tM5EzoJD2LWtP4OGjdLKNqW5vQuR27tQ+gUxAZ/goI/cu3WF4qUr4+jsYujuJMnCwgJnZycCA40L+OkpU0K6gKCQUJ0CHzBK2AOs2n+SBZv2kycZbEXgXtgnDs4bS61yJQ3XuXRUKsFVduvRU1kDXx0VK1oUpVKJ36tX9PyxFwvnz2XKtBmpWvcAAQHvyVE452fv2dhlJyoyjJgYBdbW6qdgSIzUAXj5/DHhYcEULl4uzWO0AnxBEOoBiwBzYI0oirO++Nwa2ASUAQKAtqIovtBG25rq6cPbjBvYmoXrT1GyrLwWObm6uOjdwldYOeh0izmvHNmoVrakwSYnP4WG8/zNu6/eFxAo5p1L64vBVFFcnJJ1h8+w9eBZIqOi+V/Fkpibm/FzpCuuQvwtel0ZjiKbFTXKFNd7/6QoXy4PHOxsufnwGR0b1U6xjDYnbg0RqXP//j06d+nKmzev07TuAYqX+I6At5dwz/Xf6uOg91fImbtAirBXd+J24fQhRIaHsmL7xTTLaQx8QRDMgWVAbcAPuCYIwiFRFO8nK9YTCBJFMZ8gCO2A2UBbTdvWhjK5ZgGQ7cStVB9+lKWDLPLppKZKpYpyeLn0vUO1pQXbD7J8x1E8beyS3hOBJ+EhHNdz/ppE9Z+xnH8v3aK1whE7wYITR65gY2nJXkL4UemKmLgCt28PrbgAdCkzMzM6NqpFvlwehu6K1pXd3R1XFxfu37tLx05dmDJ1errHjPx5ON26dEUZG4aTa2nCgh/y9vlG5i5cptW+eecvytG969NNw62Nq6c88FQURR9RFBXADuDL4OamQOJmkXuAmoJM4s9cMscDPyghFj/xEUkOcnZxMzofvtzVs0ltLM3NmRSVhfnR7syPdqdDpAOFsmfj+5L6WziTqEe+/hy7eI1fYrJSxsyewoItQ+LcyB5nzhnlJwLFWG6IEcQ62dC8egW9908dzR3Rlz5tGhu6G1qXIAgULVKYB/fuqHxMiRIl2b5zBwW8PvLJfyGeWZ7w27rNVPlfDa32zbtAMaIiI3jj9zzNctoAvgfwKtlrv4T3UiwjimIsEAxk/rIiQRB6C4JwXRCE6yGf9GNxO2eKT+mqjoUv9dFLaspUFxcXAjNYWGZQSCilWv7I5kOnDNJ+LvcsNPuhIofM4je2EEWRXTZhTPipo0Gs52sPnlLK3B4b4b+2BUGgssIGr+zZ2GsenGDdd5C9dZ9c0YoYoqJ1l0feUCpatCiPnzyRlCO/YMFCzFm4jEMn/2Dxb2spUaqs1vvlnbBx07PHaQ9GsrqCRFFcJYpiWVEUyzplyqKXNs0tLHDKlJmgADmutnUlKOiT5E0O5CwHO1t8Xr3m9YcAg/VhdI/WnBBCCRbjuC6GIzrb0qRq2pNdulIONxf8+Dr3jL9FHLUqluKUMtig1r06G6X4+L0hR/VWHPj9kg56pD2p4/osVrQIMTExPH3yWAc9kq7EdO5eeYsgCEK6K261AXx/IPk0tGfCeymWEQTBAnAmfvJWb4pQpD5dMW3xLtp1H6bH3qgmV1dXYmJiCAszviyDqcnSwgIHO1s+hRhuniHRyj9oFmxQ6x6gWuliiE427CaIGFFEFEWuKMO4aBZOvzYNmNy7A/N//tGorPtc7lmxMDfnZiqbu4BxZs6E/yZu792TVyI1G1s75q46QuPWPdMsp42r6BqQXxCEPIIgWAHtgENflDkEdE34uxXwuygjs7V46Upk9/QydDe+UvIEahlJmRwdCAoJ1Vn9vm/es/3URc5cu0VsbMoLvEb3aM0hZZBBrXuIX/17aPEknuXPRDdzX3pa+rHdTcH22aPwzOpG/7YNqVG2hMH6p44sLMwpXiAPtx4900t7uowq+1K5cubEwd6e+zoEvrpJGctU/AFXN/c0y2gcpSOKYqwgCAOAk8SHZa4TRfGeIAhTgOuiKB4C1gKbBUF4CgQSPyhoReEKc5U3QklND+5cw/+lD7UayiJwKEmJCdQCAgPJlStnOqWNRy5ODnwK1f5NKooiYxZvYPORc5SycOAdsUTYmnNw0QTy58zxWdlc7lkY1bkFZYsXMLj1nDObGyd/m8abj4FERivIkwFy6pQslI8dx86iVCoNfn61KTMzM4oUKcyDe7cN3ZWv5P/yGX+eO5pmGa3E4YuieAw49sV7E5P9HQW01kZbutDpIzs4fXi7DIGfMS382pXLYidhj15Vtf+Pvzl2/BK/xXnioIyPpz8WHUyn0XP5e8v8ryD6c/e0Y6j1rS9TJxuzShXMy+rdR3j26g35c2esEM1iRYuybcdO4uLi9LobXXp6+ugOK+aNTrNMxhl6NZBr5qyEhX5CodDttoVS5eoaH8iU0UIzf+nfjZ97au0hL0mbD5yhWbQDDsJ/N2E9nPj48RMPfb+cVjJJl/q+THGmDOiOk71tqmWM1Y9ftEhhoqKieO6justKyn7W6ipvgWLplpEt8NNZP6BVJS6+CpbZ4qtEl05Gs/B1pYjIKBy+uKTNBAF7M3MiInV/w2VUqROpk8cjO0O6tCKbzJ9a1I3UAflM3CZG6mT3zIO1TeoDLMgY+PpUIvDV2flKl7J3cMDS0pKADJZPZ87aHeSupX0Lv1GNSpyyivgsjPWBGEmYuUiJ/F5ab8+ktPUh8BNX7+g2FbYhlNfbG2tra51O3Kojc3NzvPKmvXjQBHzAxTU+k53c0isIgoCLSya10ivIWRYWZgSFhBIZpV0XWs9mtYnzdGGC1XuOKT+xQQhkhsUHloz5CUuLbz5PoN41feUWWg6eqJd1JPqM1LGwsKBwoUI8vK/6ilupUjdSxzsdt44J+EDegsVZf+AGJcrEJ0+TU3oFV1fXDOfDz+QYnyJZ26GZdjbWnPxtGgOGdSa0RkG8Wlbm/LrZNKyi/ZWNJqWvUoXzERwWzovXbw3dFa2raJHC3Lt3P93cNfpWn6HT0vzcBHziFy145S2Mja1d+oW/kK7TK2RyyUxAgH5Xpeo6+6CLU3z97wM/ab1uK0sL2tepym8TBjD5p47k9Uw7Ltkk3alkwfhUyRl1AVZoWBh+r16lX1iPcnZxS/NzE/AT9PDudSYN6yC7SJ3ChYtw89Zt/r15y9Bd0ZqKJ2ziMXT2sgyVNsKkz7X1yBkAnByMbw/b9PTo8RPMzMwwMzcuhMq6t5HRqnVP1b1t00qvEBIcxIXTB9i2Rntbj2lD/QcOxj1bNkaMGkNUtOqDkSH9+OnlOs+Xy4PDy2YwbWBPjRYYSd2NSU4Kj4zika8/oRGRhu6KThQUEsqpy9cZ2LE5NSumvquctvLi6ysnPsDjJ0/YvHUbbdt1wNNTNwsi1cmJr1QqGTcw7bUlsga+FGkK/fJValOrYTu2rp6Lr89DSX58Xbp1HB2dmDpjDs98fFiwcLGkdjSRpjdQrJV9mjdzxZJFqPJd/ATT0m37OXX5ulrtGBv0RVFk6qrt5G/am6Z9J1KgaR/GLt5IXJy8fMHJpc45dnFy5PzGhUwZ0D3VMtqCvSaSahiJosiUaTOxt7dn0JDhOuqVNCWy6vIfR7n8x7E0y8oe+Kpa+dpQv5GzsLN3ZN4v/VEqlbKB/vdV/0fbdh1YvW49N/79V/U2NLTytWE1pXdTRyti2HXiHG2HT1Y7ZXKcrYPOwR8WEcWdZ74p/kjZsHv57mMc2HuWhbE5WKHIwbI4D84dvcTcTft02Hv1JfW83nv6guFzV6CIicHFyTHVlajahL0+rfvTZ3/n0uXLDBoyDFdX1dcYSJ27kypRFNm2dh7ZPbzSLCfI1Yeap2BZcfKq/6w+W2vVLCBV8+rYWaV8k544sJnZE/owfvYGajZok7SoQaU6JYZSSVl9FxYaSpOGdbC2tuLYoQPYSEhNoOkOWNoIeUtrci4kLILOY2Zw7sq/jO3dkVE926vt6lFnkZAq+nXrAaav2YWn7eegeh4Ryrapw2msYgK2os1/YmCwPQWF/xbIvBKjmWjzkRfH1mm1z5pKKuzffQykRo9hxMTGcX7jQrJn+WrLC0D7lr26wJdqEEVFR1OnfiNsbGzYf/gEFhJCfaUAX4rxmGiU3rx2gaE96jFk/EIWThtyQxTFFEPTZG/h60qpuXbqNu3EuFnrqV6nBSAtRFOXVr6DoyPTZs7F5/kL5i1YKK0dGcTlp3WTOznYsXv+JNo3qMmMVVsZNnu52u3oytLvVL861pYWTIjKzKJodxZFu9M7ypkczs7UrVha5XrehYSQk8+vqRxY8TE8XFZuHannMTIqmvY/TyPgUwg7f50oe9iro7XrN/Dy1SvGjP9FZ7BXV9vWzsPFNSv1mnZOs5zRAF/bE7ipSRAEajVsi7mFBZER0q1FXUK/cpXvad+hE2vXb+T6jX+ktaMB9LV1U6V1s1tZWvLbpKGM6NaGovm8NGpHF9DP5pqJLg1/YJ/Ff2sHdlmFMrpXG6wsVb/5y+TLw9/i5087V8VwSubyxFwGER/quMeUSiU/TVnAjXuPWT15BKUL59dR77QnqffDu3fvWLZiJXVq16Jyle911Cv1JmsBGrfuyU8jZmas1Ar6jNp58ewBHRsU49LvhyUvxFL3S1NFI0eNxcMjByNGjSEyUn8RHvqAviAITOzXlV6tGgJw6Z87fFAzVl8X0B/WuTl/EMpHMYZ7YiTvrKFjvWqS6vhlQCfWW37ioPiJZ2IUx5SfWGEZyJRBXdM/WIfSZB7k2avXnP7rOpP7d6PxD5VTLScX614d42f2vPnExsby85hJ0trSoXWfnEtVazalduP26R5jVMDXhVKDvmeufLi4ZmXR9KGEh4XodPWtlIvC3t6e6TPn8cLXlzm/LpDWjgwmcSH9CB6AsIhIOo+eQa1eI3j26rVa7Wgb+smtfHWse4BKxQtxZOkvBFbMzYos0fiX82TfwvHULKf/TU4SIa/pecqf25MrO1YwuHPLVMvIBfbq6J9/b7LvwEF69PyRnLly6awddQxFP9+nrF82lbCQTyqVNzrg68u1Y2FpyfBflhLw4Q1rF/8i+XhdunYqVqpMp85d2bBpM1euXpPWjkygD2lDwMHOlh3zJhIcGk7tXiO4fu+RWm1oG/rDOjfnd2WIWtZ9okoVyMOmGSO4sXMx2+aMolwR/bpAtBXV9NfNe6zYeQhRFPHMliXViXY5hF8mSur1r1QqmTxtOtmyZaV33/7S2tKDdb9j/QK2r5uPQqFaAIjRAR/059opUqI8zdr35cCOldy/dVVWrp3hI0eT09OTkaPHEhERIelYOUziJiotGFQoUZjTa+bhYGtDo5/GcPziVbXa0Cb0s7lmYmz3Vswe1kOydW9oaTN89bn/Gzr8PI1Vuw4TkUYSPF3AXp/W/d79B7h1+w7DR47B3l53A5c6rPj4/jWnDm2lfrPO6W5tmCijBL4+1WvQL7hlzcG5k3sB3SZWk2IR2NnZMWP2r7x89YrJ02ZITlEgh0ncRKUFhfy5PTiz9lcKeuXk1J/SnmaSS1vuC4DBHZvSrFoFjevRl7S9TuFTaBith/6CUimye8Ev2NumfN3KybIH6dd8aGgYs+fN57vSpWjStLm0tvRg3e/Zsoy4uFjadhuq8rHGZaIkU2S0mUqx+arueRuhsEgxNt/O3pEV2y+oPIJ+VW+ctaT4/Ciljcrx+eXKV6BvvwH8tnwphQsVpFuXtEOyvmrL0kHtGH2FlYNWU9LGWtmnGqufNbMLR3+bhY1V/IX+IfATbi7OasfqJ4efruL2DS1dhafGxMbSdcxMnvu95eDSaeTLlfL2hbqCvT6t+6UrfuPjx4/8tnq9TvcYVse6Dw0O4tDO1VSv24ocOfOofNw3YeFr6trJnCU7giDw+tVzXr96LivXzuAhw6ldqyZTps/kwsVLOmsnJenT0news8XCwpzA4FB+6D6UAdMWSVrhmpqSW/7GlqYhJen6/7hw/TZ/XLvF4rED+P674jprR9uSat0/f/GCdRs20qJVa4oX1/+EempKZE94eCily/+PDj2lpXcwmpW2qUlfK3BjYhR0qFcEt2w5WLLxLBaWlrJZhRseHk6HNs14/eYtB/bsxDuP6iM+aLYSVxcbT6S1KlcURaav2sKctTuoXbksG2eMxsEu7dhjdWVM1r8+B6uHPi8p5J16tIrcrHt13Jc9e/flytVrnDjzB1myZJXWno5W1YJqLuUfitsZ30pbpYrjkL4mcC0trej/8xwe3rnOpt9mAPJZhWtvb8+yleuwMDenV5+fCA4OltaWjPz5kHbYpiAIjO/TmUVjBnD2739o2Hc07wN0s0GMMVj++urf8YtX+f1KfB4nY4K9OvrjwkXOnvuDfgMHS4a9LpXIm3+vnsf/peobqCeXbIGvC2kK/ep1W1CvaSe2rpnLnX8uS25fl64dT8+cLFm+ild+/gwYMoxYie4OuUEf0oZH9+b12T53Ag+fv2Lc4rU6aT+55AR/fffl9uNn9Bg/m+krt6QZHCBH2Eu9rmNiYpgyfQZ5vHLTuUvqmT5TbU+H1j1AbEwMs8f3Zs6EvpKPBZkDP1zFhaT6zKg5cMyvuOfIzfQxPQgLDdapP1/qTH/ZcuWZNHkaFy/9yYzZ0vP6Gxv061ctz/GVs5k9rA+A3jZTMZTf3xADzpsPAbQZNplMjg5snTNO77H2+rTsATZu2YqPz3NGj5uElZV8tjpN5MzvJ3bz7s0r2vVQPTInuWQNfNA+9DW18u3sHRk3az0Vq9bDwsISkE+oJkDrNu3o0q0H6zZsZOfuPTrqVcoyBPS/K5IfV2dHoqIVtBwyiWMX/tZJH9KSruFvqCeL8Mgo2g2fQnBoOLvmT8LdLeV0wHKFvVQD5mNAAIsWL6V6tf9R/Yea0tvTcZI0pVLJtrW/kidfUSr+r75adcge+HJUkZLlGTJ+ITa2dmpZlbp07QCMGj2Oqt9XYfykyVy9Jm1jETktykqu9KASHhlFYHAoHX6ezrp9x/XUq6+lTfgb2oW05fBpbj56xrppP1O8gLfB+qEv/bpgIZFRUYwa94vO21InBfJf54/h++wB7XsOVztM1CiALzcrP1HPHt2hX4f/8fb1S1m5diwsLJi/eAU5PT3o238gr/z8JB0vR9cOpA39zJmcOLpiJrUqfceQWUuZsmKTwffLVdf1Y2jQJ6p360acWTuP+lVTX2SWUaz7u/fusWPXHjp36Ya3d17p7ekhBbL/y2fkylOQGvVS38YwPWYZBfBBntC3s3fk5fPHzBzTk7i4OFm5dpycnFm+aj2xcXH82LcfYWHSQgzlDP3UIGNva8OOuRPp2rQu89bv5JdlG3TWD3WUFvzlNCl84Owlnr16jSAIlCtWKNVyGQX2oijyy9TpZHZ1pf/AwRq1rYrUse4B2nQdzNq9VzGXkIv/SxkN8OWo7J5eDB63gNv//Mn2db8Cug3VlKo8ebxZsGgZj588ZejIUSiV0jbYkCv0IXXYWFiYs3jsQCb370b7BtL9sPqS3BZ8iaLI5X/v0mHkNLqOncXUFZvSLC9X2Kujw0ePcf3GPwwZ/jOOjk6Sj9eHdf/i2QMgPqljakrPugcjA74crfzajdpTo35rNiyfxv3b0pN76dK1A/H74Y4ZN5HTZ84ye958vbo5DAV9QRAY2rU1hbxzIYoiizbv5bn/G532xZj1x9WbVO86hHp9RvHnv3cZ3rU1S8YNSrW8nGEv1UgJCwtj5uy5FCtahBYtW2vcfnpSx8h78uAm3ZuV4cTBLRq3b3S5dMIjwV6FhZX6yrUjCAJDxy/i3q0rHNixiiIlyhMVayVpFa4UScm1k6jOXbrx9MljVq5eg5+/P7OmTcXRUbUbQ5N8O6D9nDtfKq0cPADP/d8ya802Ji/fSNUyxalTpRyFvXNT2DsX7m6uOs2RIieJosjr9wHcuP+IG/cec+PeY1ZMGkpO96zc9/ElLDKKhaMH0K7BD9ilsV+ynGEvVX7+/vzYtz/v3r9n/uJlqW64npZ0nSTt3ZtXTBraASdnV77/oVGqZVWx7kHGqRVyFygrjl6ceoSJKtAH/aVeeP/WDydnV2xs7VAoorGyspZN6gWID+las3olC+fPxdPDg2WLF1KsaBHV29NwI3TQTRqG5EoN/G8+BLBg0x7O/HWDpy/9k97P5GhPo+qVWT5hCAD/PnhCjiyZyZrZxegHguCwcAQEnBzsuPzvXbqNm83bj4EAWFpYUCx/HhaPHUjJgnmJVsRgaWGOmVnaT8Zyh70U6/7GP//Qp99AohUKFixaRtX/Sd/bQCrspfru3715xdDudQkJCeLX1UcoWLRM6nUnA37DMlapplYwWuCD/KAPEB4WwuButanZoC3tug/F1jJGpTqT6pYAfqnQB7h+/RrDB/cnMDCQCePG0qlDO0lwM2bwQ3ymzQc+vtx/5stDn5fkyOrGzz3bIYoiXrXbExQSiquzE4W9c1HIOxd1q5Sj3vflddpfTRUbG8etx8+SLPcb9x/x+IUf83/uR69WDXn55j1Tf9tEmSIFKFO0AMXze2Njrfpck9xBD9Jgv3vvPsZNmESOHDlYvmodefPmk96ejmEfGxNDjxblCAx4Jwn2kIGBD/KDvkIRzezxvfn9+G6atevDgNHzsLdWrc6kunUM/cDAQEaPGMT5Cxdp1LABM6dOUdnFA9qBPhgW/F9KFEX+uHaTBz4veejjywOflzx45kv35vWZOqgHEVFRlGzeiwJengkuoXi3UNH8eXB20F/ed6VSybNXb7hx/xGuzk7UqVyW4LBwctZoA0AW10yULVqAMkUK0rBaRY02hM9ooI+Li2P23F9ZtXYdVSpXYv7i38iUKZP0NnUM+0Rd+v0wWbLlkAR7MFLg58xXVhy7VLVFQ3KDvlKpZNXCCexcv4AqPzRi/OwNZHKUNl2ia+grlUrWrPqNhQvmkdPTk2WLF1K0SGHV29QS9EFe4E8uURRRxMRibWXJx6BgJi1dz4PnL3no85KwiPgIglnDetOvXVP8331k0Za9FPbORWHv3BTyzkUmCYNoepq3ficX/7nDv/cf8yk0/v9p+L+KbJ83AYCTf16jSN7caW41qIp0uWmJtv30UmAfGhrGoKHDOXf+PB07dWHMuIlYphHxkmqbOob929cvefboNlXS8Ncn1Z2K395ogT94zlXs7VSLuJEb9AH2b1vBklkjqNukI6OmrQKQlV8f4Pq1qwwfMoDAoCAmjR9Lh3Zt9e7iSZRcwf+lRFHE790HHvi8pKBXTnLnyMalf+7Qasikz7b7y5E1M+um/kzl0sV4+zGQl2/eUyhPLpwc7FKsNywikpsPnya4Zh6hiI1lx7yJADTuN5agkFDKFC2Q4JopSKE8OdWaaEwufe1KZUjY+/q+pFfffvg8f874iZPp0FHaRkGg3uSsOrAf1qMeERFhbD12F3uH1ENE05qk1RnwBUFwBXYCXsALoI0oil/lqhUEIQ64k/DypSiKTdKrOxH4gFFD//IfR8lXqCRZ3T2T3pMb9AMDAhg9cjDnL1ykccMGzDCQiydRugZ/cmlrEID4p6aXb95/5hYa07sDeTyys2bPUYbNWQ6AZ7YsFPLORZG8uRnapRWZMzkzZsFqVuw8lLRWwitHNiqVKsZvk4YiCAJKpTLdSdX0ZIgtB3URfSMF9n9ducJPAwYhirBo6QoqVaoivT09wl7qBG1K0iXw5wCBoijOEgRhNOAiiuKoFMqFiaIo6ZtPDnyQP/QhbfArlUoWTR9CvWadKVy8nOygn9zFkyunJ0sXGc7Fkyh9gv9LaXMgAHj3MZDr9x7Fzw0kDAhPXvrz9PhWnBzsOPj7n9x7+iLJgndzcdaoPUPvJ2to0ANs27GTiZOn4pU7N8tXriO3l5f0No0M9qBb4D8Cqoui+EYQhOzAH6IoFkyhnMbAB+OGfuDHtwzoVIPAgHdMnLuJytUb6hT6oL6LZ9iQ/gQFfTK4iydRhgT/l9LmQBAXF6exSyZRhgZ8onQVTy8F9rGxsUybMYsNm7dQvdr/mLdwmd5W0KozQbt93Xy2rpmrFdiDboH/SRTFTAl/C0BQ4usvysUCN4FYYJYoigdSqa830Bsgk1uuMuNWPv+qjHFD/x1jB7TkyYObDB63gCZtfpQl9AMDAhg1YhAXLl6iSaOGzJg6GQcHw7l4EiUn8CeXtp8G0pNc4P6l5GDVBwcH03/QUC5dvkyPnj8y4ucxeltQJRX2oigiCAKiKPLhnf9nbt+v6lYR9pA28NOlpyAIZwRBuJvCT9Pk5cT4kSO10SN3Qgc6AAsFQUgxHZ0oiqtEUSwrimJZB+csKVYUHqEaoA2VhgFS/3Jc3bKxYN1Jyn9fhwVTB7Nl9RzJuXd0uVViolwzZ2bl2s0MG/4zR44dp3Hzltx/8FD1Ni0ddJJmWWHlYJAVmekpMaHblz+6qltu0sX3os419MzHh2at2nDl2jVmzJrLqDHjJcM+SmmjNzfOgE4/8OLZAwRB0Brs0+NUurQTRbGWKIrFUvg5CLxLcOWQ8Pt9KnX4J/z2Af4ASqv8H6QgY4a+rZ090xbtonmHnyhZtiogfQMVdaAv9SI2MzOjz0/92bRlBxGRkTRr1YZtO3ZKysXzrYH/S0kdCIwB7smlq+9BnWvmwsVLNGvVlpCQUDZs3k7LVm2kt6tmmgR1YD+0R118nz8iOioi7bq1CHvQPHnaIaBrwt9dgYNfFhAEwUUQBOuEv92AKsB9Dds1auibW1gwaMyvFC9dCYDTR3bwMUjFjibWrUYSJnUu6HLlK7D/0HEqlC/H2AmTGDxshFqplr9l8H8pXT4R6EO6BL06qY3Xb9xEt1698ciRnV37DlG2bDnpbesZ9qEhn7TmswfVuaQp8GcBtQVBeALUSniNIAhlBUFYk1CmMHBdEIRbwDniffgaAx/kAf1Hd68xrl9j2lTPTt/W5ThzePNnVnB6X9obvxfMmdCHwV1r88rvvc7TK6tj7WfO7MaqdVsYOmwkR44dp0mLVjx4+Eh62ybwG73kAnoAhULB2AkTmTxtBjVr/MC2XQfw9MwpvX09wf7DWz+Dwh40BL4oigGiKNYURTF/gusnMOH966Io9kr4+7IoisVFUSyZ8HutKnUrlaq5DgwJ/bt3bjOuX2NCI4pTpMIqnLJ0Zt3i6ezfsvizshEKi1S/wOyeXsxcto+3r33p17E6Po/v6iWnvjounr79BrBpyw7CwsNp1qoN23fuUivdsq62UTSBX3eSi58+UYGBQXTq1oPtO3fT96f+LF6+Bnt76U9J6vrr1YnGcXR2JX/hUgaDPch4pa2Hdxmxz9Qr2NmqGJVjgOidOaPaEBiQg+x5Wia9Fxn2ikc3hrD11Assrb6+KFKL4Hn66DZj+jUnMiKcKQt38F2F6pJTLOsriicg4COjhg/i4qU/adq4ETOmTlbrZgPdRfSAfKN6jElyCLP8Uo8eP6ZXn368e/+eGbPm0rhJM+nt68Gqh3jYv3/rh72DU5orZ5Pq1wLs21QyVz9Kx9CKiFTRgjeApf/i8S2c3T4fqW0dciIIVgR+THnDjdS+0HwFS7Bs63myuHvyxi8+HFXXk7mgmYtnyLARHD56jMZqunhAd24eMFn8mkhOfvrkOvv7OVq0aUdUdDRbt++WPezfvn7J4G61mTqyS/r169CyT5TsgQ/yhX42D2/Cgh9/9p4iKoDYmHCcXVIOK4XUv9is7p6s3PknDVt2B+DViydExkhL8KRPF89P/QayYdM2QkPDaNaqDTt27VZ7Ry0T+A2rxHMkV9CLosjK1Wvp1bcf3nnysGffYUqULCW9H3qG/dAedQkLCab7gAlp168H2IMR7XgVEalUyb0THqFUyb2jjZ2zWnQdwa9jO2FtkwWnzKWIjnyL74Nfqdu8Jza2abs4vtxB6+jeDbx68TTpdcinQE4d3ky+QqVYtOE0zg6qj82JF6dUF486u2lVqFiJA4ePM2rYIEaPm8CVq9eYNnmS2i6eRCjowtXzJci+VZePPgc/bQzi7z98YOr0mRw+eoyGDeozffYCbG1V9M0m74uO4+uT2vkC9vNWHzaYz/5Lyd6H/6Xk5tP/+/e9bF46lk8Br7GwtKZOi770HDBB5Z3lE6E/dmAH7t16iku2+FBNURT54H+ayDBfKlVrwMS5mySnWAb1/Pog3bcfFxfHyt+WsWTRAry8crN04QKKFC6kVtuf9UOHPv7UlNEGAkM83WgD9FHR0axdv4Hlv61EoYih34BB/NRvoOT0z/qy6uG/FbRDutXB58k9g8A+LR++0QEftA990Az8oigSGRGKtbVdEuilpmJ49ugOg7o1pETVLZibx1+gT2+OpVCR7Fw4vY9CxcsyY8ke3LNKT6qlL+gDXPn7L4YPHUhAQADNmjZm6MCB5MyZ+ipClftiAPAnl7EMAnJwXWkKe1EUOXLsOLPmzsPf/zV1atdi+KjxeHnlkd4XPcM+Uf4vnxEWGkzBot+l3oaOLHujnrRNSVJ8+vrw6wuCgJ2902dWfbjCXOUvKUJhQfY8pSlRpjLvXh4CIDToAdERzxk7cw1TFmzn2aM7HNy5mqhYK7Umc/W1UKtCxUocPnaabj16cfTYCWrUrc/4SZN59+6d5Lo+64sOffyq6EsftxzAKrc+aeM7unX7Dq3bd2TgkGE4OTqxYfM2lqxYaxSwf+vvy8YV0xFFEY9ceQ0C+/TmHY3Swk8uubl4UqxTRWv/+ZPb/NyrHiWqbuH5nSm07dKa5u37xH/29D658hTE3NycuNhYzC0sJIdtgn6t/Xdv37Ji+RJ279qBubk5XTt1pG/vH3F1dVGrD5/1x8AWf1rS1dOAoYGemrQxEL9585a58xew78BB3DJnZsiwkbRo1UbtbKKGgP3QnvUICwlm9e6/cPfInXobOoZ91+qC8bl03HN/J/abcTX9gmQs6P8ypDUvfMKJibzHztP3sfoilv/DO3+G92pA76HT+L5GY9lDH+DVy5csXbKQgwf2YW9nR88e3ejRtQvOzprlfAd5gz+5pA4CcoV7cmkD9KGhYazdsIHfVq1BqVTSrXsv+vTth4Ojo/r90tPkLHwNe0NN0Ca37NMCvqxdOuHhMSqVk2vY5md1qvjlde0/gQ/+Z+jS9+evYA9gYWGJvYMTEwa3Zfnc0YRESB+w9eniAciZKxez587nyLFTVP2+CouWLKN8lf8x7OdR3Pj3X7VDOcHwrh5VlZb7RW6uGVWk6Tl/8PAR4yb+QsWq/2Ph4qXU/KE6x06eZfjIUWrDXh+ZLj9rL9aKq5dO0afd97KBfXqStYXfddyfANjbqxaLnlEs/asXj1G6Qk2cHVL+0qMiI/jt17Ec3LkK7wLFGTNjNfkKljAKax/g4cMHbN+2hcMH9xEeHkGhggXo0K4tzZo2wUkDyw6Mx+I3VmkC+uhoBcdPnGTL9u1cv/EP1tbWNGzUhA6dulC8eAnN+mWgydl/rvzBb7+OZfzsDeTKUyDlNiSAHjSHvdG6dBKBD/KHPujGxQOpp2P468Jx5k74idIVqjFhzkZA2n65n7VhAPCHh4dz9PAhdm7fxN1797G1taVxwwZ0bN+OEsWLSQ6/+6xfJvBrTZpa86/8/Ni2Yye7du8lIDAQr9y5adehM81btiZTpkya9U2PoId4eJ84uJmP717Tpe8YgDT3G9ZljH1qln2GAD6YoJ+SQoIDiY2JwdUtGy+ePeDhnevUadIxzf1102xHT/l4vtSdO7fZuX0rRw4fJDIykqJFitChXRuaNm4kabetFPtngr9a0gT0cXFxnL9wkS3btnPu/AUEQaBWzRq069iNSpWraLwhO+jfV//4/r8snD6EB7evUarc/5i3+miak8qGcuFkGOAnygT+lLVs9s/s2bKUoiUrMHjcAvIXLmU0bp5EhYaGcOjgAXbt2MLDh4+wt7ejaePGdGjXlmJFi2hcvwn+X0ubcyABAYHs2rOXrTt24OfnT5YsWWjdtj1t2rQne44cWmlD3+6b0OAg1i6ZzKFdq8nkkoU+w6dTp3GHVJ9ADWHVJ1eGAz6YoJ+SlEolJw9uYdXCCYR8CqBx6170HDiJLJnVS3NgSPCLositm/+yc8c2jh09TFRUFCVLFKdDu7Y0btgAOzs7jdv4Uhl9MNDV5LYoitz451+2bNvOseMnUMTEULFCedp17Eat2nWwtJSWDyo16dt9k+ir9/N9Sq9WFWjQohs9+k/AwSlT6m3JYGI2QwIfDAd90A34tWXphwYHsX7ZVA7uXEWn3qPo3j8+cZMx+feTKzg4mIMH9rFr+xaePH2Ko4MDzZs1oUO7thQqWFArbagiYxgQ9BmxFBYWxoFDR9iyfTsPHz7C0cGBZi1a0a59R/LlT3kCUx0ZAvRPH97iwpmD9BgwEYBPgR/I5Co9IWJq0hXsIQMDH1SHPnxb1j7A04e38MiVF1s7B+7e/BtLS0sKFi2jVzcPaA/8oihy48Z1dm7fyonjR1EoFHxXuhQd2rWlUYP62NioBwZtSN+DgSFDUR89fsyWbTvYf+AgYeHhFClcmPYdu9KwcRO1k+Z9KXUhnyh13TdhIZ9Yt2wqB3esxClTZtbs+ZvMWbKn3ZaBXThJdSeEk/erb4TAz5qztNh9wmWVy5tcPGlrcLc63PnnTxq16kHPQb+QzU298Ec5gB8gKCiIA/v2sGvHFnyev8DJyYmWzZvRsV1b8uXLq7V2tCF1BwM5rS9QKBScOHWaLVu3c/X6daysrKjfoBEdOnamZKnSGkVUJZchQA8QGWPJqcPbWPnrOII/faRJmx/pMWAijs6prwqXk1WffO2Q0QK/zdA/sHdQPW9MRnPxgPbAHxYazMbl09m3fQUODs70HPQLDVt2x95a9fo/a0sD8IN2rf6rV/5m545tnDp5nJiYGMqXLUuHdm2pV68ONtbqAcCkePn5+7N95y527trDx4AAcnp60q5jZ1q0bIOrq6vW2jEU6BP99GEhn+jYsDgeubwZMm4hBYqUTrs9mcIejBz4gAn6EqAPaYPf5/FdFs0Yxu0bl5gwdxM16rUC1PPvawp90K7VHxDwkX1797B7x1Z8X77ExSUTrVo0p33bNnjnkZ5861uVUqnkwqU/2bJ1G7//cR6AGtWr0bZjN76v+j+thFSC5pBPlNrum9BgDu9eS5uugzE3N+fViyd45Mqb5v+nS9CDei6cL2X0wE+UCfzasfZFUeSv88eoULUe5ubm3Lx2kTz5CpMtS/p7bqbYlhbAD9qDv1Kp5O+/LrN7+yZOnTlLbGwslSpWoE6tmpQuVYo8Xrm1kscnIyg4OJinz57x7Nlznvn48PTZM+4/eMibt29xy5yZVm3a0aZdBzw8NE9xnShDgh7i3Tdnjuxgxa9j+BT4gflrT1CqXNW025IIetCvVZ9cGQb4YIK+Nq19AIUimnZ1ChIbE0PPQZNo1Kqnwdw8idKm1f/hw3v27t7F7l3beP/+AwpF/JOMi0smvHLnJo+XF165c+PllZs8Xrnxyu2Fo6N8fOfakFKp5PWbNzx95sOzZz5JYPfxec7HgICkclaWluTJ40WevAWoU7cetevUw8pKWiru1KQtyINm7pvnT+6xcPpQbt+4RKFiZRgyfmGa+W9AXlY9pJ/rK0MBH0zQlwp9SBv8L549YPGMYfx79Tz5C5dk8NiFFC1VwWBunuTSptXv6/uCZ0+f4uv7HN8XL3j54hkvXvjy5u3bz8q6Zc6Ml1fuhAEhN16Jg0LuXFqLQtGFoqKjefHixRdg98Hn+XOiov47j87OzuTL602evAXwzpsXb+985M2bDw9PT7XTEafaJy2CHjSDvSiK9GpZgY8f3vDj4Mk0aNFNq+4bMJxVn1wZDviJUhX8hgzdBPmAPz03zx8n97F87ig+vn/Nun3XyJO/qN5j91OTNq3+LxUZGcnLl774vnjOixcv8H3xPH4w8PXl/fsPn5XNmjXLZ08G8QNCbnLnyqXWPqvqKCgoiGc+z+NdMT7xcH/6zIdXfn5JmUcFQcDDIwd5EmDunTcf3t55yZs3Hy6urlqLqklNcgF9ZIwlf5zcR4WqdbCzd+T5k3u4ZnHHOVPmtNszUthDBgY+mKx9bVv7kRFhXDhzkLpNOgJw9+bfFC5WFnsb1fv0VXtahL8uwZ+SwsPDeen7Imkg8PV9wStfH56/8OXjx4+flc3u7v7Zk0HuhN+5cuWSHC0UFxfH69dv/oO6jw/PnsVDPjAoKKmclZUV3t558M5bAG/vvAkWe1688njrbQBKlFwgDwnum6f3WTxjGDevXaDfyNm07jIw/TZ1DHrQzsRsquUjlIxsaYR72qoKfDAs9CFjgh/g3ZtXdGpQjFzehRgybgHFv6ustsUPxmX1q6Kw0FB8fV/g6/uCFy8+dxMlh7IgCOTInv1zN1HueFdR1qxZ8PPzTwb2eKg/f/6C6Oj/zperiwt5E90wiWDPm48cOTy07oaRKjmBHiAwOJpNv81kz5al2Nk50mvwZBq27K61RGfJJRerHv7b78Moge/mUUpsN/y8yuV1AX34tq19URS5ePYgy2b/zPu3ftRu3IG+w6bh6uauEfjBuK1+VRQSEvzfU8GL+AHh5QsfXvj6EhwcnOIxgiCQ09OTPHkT3DDeecmT8FubMe/akNwgD//F1E8b1Z2zx3bSsGU3fhw8BWcXt7TblplVD+rDHowY+E37ngbA1l4CzDOgtS8F+qALN08429bMZeeGhdjaO7L9xH3s7B01hj5kPKtfFQUFBSXNF3z48B4PD0+88+bFyyuPQdNDqCK5gt7X5yF2dg5kcffk1YsnhAYHUaRk+bTbzmCgT5TRAx9M0AfDg9/P9yl3/rlM/eZdgPjoHq+8hU3g/wYkR9ADBIUo2PTbLHZvXkzNBm0ZM311+m3rwX0DhoE9pA189f5zAygyXKEy9MPDFCpDPzw8RiXoR0QqVYZ+eIRSZeiHR6oO/choM0nQD1eYS4Z+hMIiVeh75s6HZ+58ANy8doGhPepRo34bfhoxA7esOTQCf3IAaAP+yQFlgn/6un3rJkFBgZ+9p1Ba4ejkTKnvymmlDW1BHuKjb86f2s+yOT/z8f1r6jfvQu8hU9Pvgx6setAt7FXdmzslGY2Fn1yqgt/Qfn3IuNZ+dFQk29bOY/u6+VhYWNKl7xhaduqPoxYDQ7Rt9YMJ/qmpVo0ahIQqsXN0T3ovMvwDAqH88ddtjerWJugT/fS7Ny1h+dxR5CtUgiHjFlG0VIW0+5ABQA+qwT5DuHS+lMnFIx36oH3w+7/yYfmcn7n8xzGKlqzAks2/IwiCVtw8n/VBB/BPrm9lIEjNNbNv11ZWrNhO/tJzk97zuT2J9u1/oGvPnyS3o03IQzzoIyPCCQ76iLtHboKDPvLHqX00atXT4NE3iZID7CGDAh8MD334dsCfXgjnXxeOEx4aQq2GbVEqlQR8eEOWbB5GB/6UZIyDgVSfe0xMDPWqVyR7/p9xci1BeMhTfG6N4dSFq9jaqr67mC5AHxcby/nT+1k5fxyubtlYvu2CSgvH9GXVg+5j66UoQ/jwU5Kh/fpgnL59kO7fT7x5UgN/pf/VT/r7+IFNzJ88gO8q1qBOo/Z8X7MxtnYOWoF/IlD0Cf604GnowUBbk6mWlpb0HzyMFSs24+Q6l3cvNtOrb3+VYa8Lt43P47sc2bOOcyf38inwA94FitNv5Ox0Yf8tWvWJiohMu7xsLXxX9xJi8/5nVS6fUa19KZY+yMPN8+7NK47sXsvpozt49/olNrZ2fF+jCcMnLcXG1i5DWP2qSNPBIDY2lo0b1rNr136ioiKpUas2vfsNxsU17bQA6irRynfK1oqPr7ama93rwpp/+fwxrpmz4uCUiSN71rF45nAqV2tA7cbtqfi/+kbrvgHdwj456Cd1sjQ+l46rewmxbpcj2EmYBcyo0AfjBL9SqeTezb85dXgbL58/ZuH6kwiCwNlju8jplZ/8hUthaxkjuc00+yNT+Kek5ANCSpb6iME/cfOmL9m8umBhac8Hv0MIsQ/Yfegkdna6SeK2b9dWJo8fxrBRv6Tou9cF5AM+vOH343s4c3QHj+//y6Cx82nevi9RkRHExsbg4Jh2KutvGfTwtVVv1MBPlC7Aryvogwn8X0oURQRBIDYmhpY1vAn5FEDuvIWp3agdNRu0xT1HLq1a/sYE/pT07OkjOrdpQYmqWzEz/w+yz26No9ePzWjdrotO2o2JiWHBnKkMHDb6M+teFy4bhSKacQNa8c+VcyiVSvIXLkWthu2o2aB1uvvIggn0qblv0gK+RlvXCILQWhCEe4IgKAVBSLGBhHL1BEF4JAjCU0EQRqvTVkSo6mcvMlw1cISHKQgPU7FseAzh4apbo+n50j6rW8IXLfUiiow2k+5nVJhLvikiFBZp3oCJflcLS0s2H7nF0AmLcXJ2Yc2iSbSvW4h9W1cQFWuV9KOpIuKsk36MUfdu38QlS+nPYA9gl6k8t/79V2ftWlpa8vO4Kdja2mn1HEbFWhEaCWdPn2LnhoUAWFlZ4+ziRsdeI9lw8B9W7bpMm66DVNo0XN0JWXUWTxkT7NOTppO2d4EWwMrUCgiCYA4sA2oDfsA1QRAOiaJ4X2pjEaGRKlv6upzQBdUs/sQvRRVrP/ELV8XaT7yYpFj7iRetIRduJcrJ2ZUmbXrRpE0v3vi94OyxnUk7Dt26fon921ZQq1E7KlSti6WllcaWf0rAkvsTQHYPTyLCXiQ9GSUqJuIFnjkLaK0dXQ+IEQoL7v77F2eO7uD8qf2EBAfiljU7LTr2w9LSivGz10uqSx3pI/ImqS2Zgj5RGgFfFMUHQHqz5uWBp6Io+iSU3QE0BSQDH/6z9FUBf6Klrwr4Ey39jBrJkyh1VuuCNDdP8hszPfhn9/SiU+9RSa8/vn/NrRuXOH96P07OrlSv15LajdpTtGQFrfr70wOdoQeEMuUq4exkif+T9WTP2wEzMysC3pwn6P15mreaJKkufT/lJG42IggCezYvYsW8MdjY2lHlh8bUatiWspVqYmGp4r2jJuTBBPqUpI+wTA/gVbLXfkCKy+IEQegN9Aawc/JIs1KTtZ9QVo/WPkj370uBP0DNBm2oVrs51/86y+kjOzh5cAsXTx9k99mnRAnxG087ODprPdLnSxl6QDAzM2P1xh2M+3ko//zeEjMzC7Ln8GTF2s1kc//c5SEHt1VUrBXv3/px9tguzhzdSdefxvC/Ws34X+3muLhmTQrNVVXGAnowHtiDCsAXBOEM4J7CR+NEUTyotZ4AoiiuAlZB/KRteuWN1dqHbw/8oDr8LSwtqfi/elT8Xz0iwkN5+fwR5hYWKJVKerUsj2sWd2o3as8PdVuSyTWLzuGfkvQxIGTJmo1VG7YR/CmI4EjInCUbgiAQod6Ww1pX4qKo4wc2ceboTm7fuIQoihQuUQ5r6/gL0T1HLtxz5FKpPk0gDybQqyKtROkIgvAHMEIUxespfFYJ+EUUxboJr8cAiKI4M606v4zSSU9yCN8EeYRwgnRXD+gvoie5VLH6E6VQRLN/2wpOHd6Oz+M7mFtYUL5KbTr0GkmxUhUBDAJ/dZTSgCAHSz09RcVaoYiOwtfnIfkLl0IURTo1LI65uTk1G7SlVsO2eOTKq3J9mkIeTKBPaifB4zCnj51BV9peA/ILgpAH8AfaAR203YhUFw9kXGsfjMPiB2kuHysra9p2G0LbbkN49ugOZ47u5MzRHYSGxO8u9e7NK16/8qFk2aqSBhJDyBjgnlzh0ebcun6RM0d3cOHMQczNzNlzzgdLSyuWbDqLS+asKu+Tqw3Ig/xBD/qBvZToQY3OvCAIzYElQBbgqCAIN0VRrCsIQg5gjSiKDURRjBUEYQBwEjAH1omieC+9upVK6f+4FBcPyMO3D7qb1AXjAT9Ig3/egsXJW7A4vQZPTnrv6N71bF45iyzZPKjVsB21G7XTaCP2b12J4bEXzx5k8YzhfHz/Gjt7R6rWbEqthm0xM4v/zl3dsqVbl7YgDybQf9aOBNiDjBdeZcpaTKzWcq8kV01y6crFA8br5gHjcfUkl6rWelRkBJf/OMrpI9u5+udplHFxFClRniWbf8fM7PNzZRoE/lPydQ9KpRL/l884f2ofFarWJX/hUty7eYVta+dSq2F7KldvgLWN6heRCfRpSxegN7RLRyNJtdrVOU6KiwekWfsgHzcPGJfFn6j0ErclysbWjhr1W1OjfmuCAt7zx8m9BAV+SIL93Ek/oYyLw93Di+yeXrjnyE1Or/y4ZM76dV0ZaED4ciGbIjqKN/4vsLCwxCNXXiIjwpgysgv+L3146/+CmJj4/93K2ob8hUtRtFQFpi/Zo3J7coA86Bf0ID/3TUqSPfATJcVHr+5xUl08IM23D/Jw84B+Yvjh8xtWU/hLcfm4ZM5K8w7/5YIJCw3G1+cRb/1fEPDhbdL7Tdv2Zsj4hcTGxDBmQEuyZc+ZNBhk9/Aip1d+HJ1dvqpfbgPCl1APC/lEREQYWd09AVg4bQi+Pg95/cqHD+/8EUWRek07MWraKmxs7Qn+FIBXvsJU/qEhHjm9KVe5Fu4euVVuX5uQBxPoU2xHQ9iDEQEf9Ad9MFn7qUkdaz+pPQPBH8DB0Zmlm38H4i3ct69f8va1b5L/OTwsmLDQTzx9eItPgR+Sjvtx8BQ69BrBx/evmTepH+4eXrh7xA8G7h65yJWnYIrx5boYEL50vYSHBicNRns2L+XBnWu8fuXD61fPCQkO5LsKP/DrmqMAPHt8B1EUKVnuf3jkzEMOT2/yFSoBxC+cXL71vOT+yAnyIH/Qg2Gs+uQyKuCDflw8YNzWPsgb/GBY+FtZ25ArTwFy5fkvRYGzixsrtl0AIDIiLH5A8H+BZ+78QPwTQmDAO+7fvpYUFQQwduY6ajdqx9OHt1i/bNp/g0GOXLh7epHLqwBW1p9nwkxtMPjSSo+LjcXcIv5/u3j2ILev/8lrPx/8Xz3njd9zsmXPxabDNwG4+ucp/H2fkSOnN9XrtiBHTm/yFiieVNeSTaqnGk9LcoM8mEAvRUYH/ERlFGsftL9SF4wH/GAYf39asrVzIE++IuTJVyTpPa+8hVm16y8gHv5vX/vy1u8FBYuV+e89f1/+vXqeyIiwpOMWrj9FybLfc/3yWQ7tXvPZYOCeIzc5c+fHwtKS+7evcuvaRfxf+fDa7zmvX/kQGhzEkb/eIggCl88d5Y9T+8jh6U3O3Pmo8H2dzwas2SsOqhwWqY7k4pdProwKelAf9uklg5R9lI4qMkXyqFC/jCN6UmzbAFE+2pAoioQEB/LW/wVv/V9SpuIPODhl4tyJvWxYPo23r31RRP+XB3/b8ftk9/Ri3ZLJbF41G2cXN3IkuFxy5MxDp96jsLKyJioyAmsbW51C/UvJEfJgHKAH/Vr1yUG/bHgm48uHLwX4oB/ogwn8qkpb4Aftwj9RhlqYJYoiQQHveOPny9vXvlSv0wJzCwtCg4MwMzfH3sFJ733StpsmuUygV7EtDdw3X1r1aQHfaF06X0ofLh6Q5tsH+UzqJtWvZ1cPaA5/bbp8EpUW5HQ5GAiCgKubO65u7hQt9V8OwZQigbQpXUL9S8kB8mAcoAfduW9SkmyBr4zT/UpbdY9Tx7cPup3UBXmCH7Tj5wftTvSmpfTgKMe0DfoEekqSC+RB/6AHw7lvpEq2wAeICAnDzkn1lKpJx32D1j5Ii+ZJakPNGH5QH/xgPPBPSYYaEAwN9S+lTciD4UAPxuu+kSp5XUEpKCIkPuJBKvhN1r5urX1Qb/FWojIK/FOSJgOC3KD+peQGeTAe0INhrPrkkvfVlUwZ0doH4we/utZ+csnd369tyR3qKUlOLptEmUAvXbKN0hEE4QPgq8cm3YCPemzPWGQ6LynLdF5Slum8fC19n5PcoihmSekD2QJf3xIE4XpqoUzfskznJWWZzkvKMp2XryWnc6KdZyuTTDLJJJNkLxPwTTLJJJO+EZmA/59WGboDMpXpvKQs03lJWabz8rVkc05MPnyTTDLJpG9EJgvfJJNMMukbkQn4JplkkknfiL5Z4AuC0FoQhHuCICgFQUg1ZEoQhHqCIDwSBOGpIAij9dlHQ0gQBFdBEE4LgvAk4XeKWb0EQYgTBOFmws8hffdTX0rv+xcEwVoQhJ0Jn18RBMHLAN3Uq1Q4J90EQfiQ7ProZYh+6luCIKwTBOG9IAh3U/lcEARhccJ5uy0Iwnf67uM3C3zgLtACuJBaAUEQzIFlQH2gCNBeEIQiqZXPIBoNnBVFMT9wNuF1SooURbFUwk8T/XVPf1Lx++8JBImimA9YAMzWby/1Kwn3xM5k18cavXbScNoA1Evj8/pA/oSf3sAKPfTpM32zwBdF8YEoio/SKVYeeCqKoo8oigpgB9BU970zqJoCGxP+3gg0M1xXDC5Vvv/k52sPUFPQ5y4l+te3eE+oJFEULwCBaRRpCmwS4/U3kEkQhOz66V28vlngqygP4FWy134J72VkZRNF8U3C32+BbKmUsxEE4bogCH8LgtBMP13Tu1T5/pPKiKIYCwQDmfXSO8NI1XuiZYLbYo8gCDn10zXZy+A8Mb4sThIkCMIZwD2Fj8aJonhQ3/2Ri9I6L8lfiKIoCoKQWtxublEU/QVB8AZ+FwThjiiKz7TdV5OMUoeB7aIoRguC0If4J6AaBu6TSWRw4IuiWEvDKvyB5NaJZ8J7Rq20zosgCO8EQcguiuKbhMfN96nU4Z/w20cQhD+A0kBGA74q339iGT9BECwAZyBAP90ziNI9J6IoJv//1wBz9NAvY5DBeWJy6aSta0B+QRDyCIJgBbQDMmxESoIOAV0T/u4KfPUkJAiCiyAI1gl/uwFVgPt666H+pMr3n/x8tQJ+FzP2asZ0z8kXfukmwAM99k/OOgR0SYjWqQgEJ3Of6keiKH6TP0Bz4n1o0cA74GTC+zmAY8nKNQAeE2+9jjN0v/VwXjITH53zBDgDuCa8XxZYk/B3ZeAOcCvhd09D91uH5+Or7x+YAjRJ+NsG2A08Ba4C3obuswzOyUzgXsL1cQ4oZOg+6+m8bAfeADEJbOkJ9AX6JnwuEB/h9Czhvimr7z6aUiuYZJJJJn0jMrl0TDLJJJO+EZmAb5JJJpn0jcgEfJNMMsmkb0Qm4JtkkkkmfSMyAd8kk0wy6RuRCfgmmWSSSd+ITMA3ySSTTPpG9H8+Pyf90UNnPgAAAABJRU5ErkJggg==\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "# Create the progress bar and the total kernel evaluation number N needed for visualizing the decision function\n",
    "pbar = tqdm(total=100, \n",
    "            desc='Calculating the decision function of QKE-SVM', \n",
    "            bar_format=bar_format_string)\n",
    "N = 10 ** 2 * len(X_train)\n",
    "    \n",
    "# Visualize the decision function\n",
    "visualize_decision_bound(svm_qke)\n",
    "pbar.close()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "quantitative-reliance",
   "metadata": {},
   "source": [
    "We can see that the quantum kernel has the ability to learn non-linearity correctly. As a matter of fact, the performance of quantum kernel methods in classification depends on whether the quantum feature map can distinguish non-trivial patterns hidden in the data. Currently, people are still exploring how to design a good quantum kernel: First, we may try different designs of encoding circuits; Second, we can train the quantum feature map to improve its classification accuracy [5-6]; Finally, we can also try variants of the quantum kernels [7]. \n",
    "\n",
    "In the following part, we will introduce another special kind of quantum kernel - projected quantum kernel. "
   ]
  },
  {
   "cell_type": "markdown",
   "id": "residential-williams",
   "metadata": {},
   "source": [
    "### Projected quantum kernel\n",
    "\n",
    "It was mentioned above that quantum kernel methods can potentially distinguish intractable patterns by mapping classical data vectors into a quantum feature space via a quantum feature map. However, as the quantum feature space - the Hilbert space's dimensionality grows exponentially with the number of qubits, nearly all quantum states will be perpendicular to each other when we have a large number of qubits. Then the kernel matrix will just become an identity matrix $K_{ij} = K(\\mathbf{x}_j, \\mathbf{x}_i) \\sim {I}$, and the kernel methods would fail. To avoid this problem caused by extra dimensionality, we first need to extract features from the Hilbert space and then construct the kernel function with these extracted features. Following this idea, a variant of quantum kernel - projected quantum kernel is proposed : By projecting the quantum feature vectors back into the classical space with a set of measurements, the dimensionality problem is mitigated [7]. Also, as the projection can preserve important features of the quantum feature space, the projected kernel can still gain a quantum advantage. \n",
    "\n",
    "There are several kinds of projected quantum kernels, here we choose the most rudimentary one:\n",
    "\n",
    "$$\n",
    "K^{P}(x_i,x_j) = \\exp\\left(-\\gamma\\sum\\limits_{k}\\sum\\limits_{P\\in \\mathcal{M}}( {\\rm Tr} (P\\rho(x_i)_k)-{\\rm Tr}(P\\rho(x_j)_k))^{2}\\right),\n",
    "\\tag{13}\n",
    "$$\n",
    "\n",
    "where $\\rho(x_i)_k$ is the reduce density matrix of qubits $k$, $\\mathcal{M}$ a set of measurements on the reduce density matrix. Here we take $k = 0, 1$ and $M = \\{X, Y, Z \\}$, which means using Pauli measurements to measure every single qubit at the output.\n",
    "\n",
    "Let's first try to implement a projected quantum kernel circuit with Paddle Quantum:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "id": "acute-environment",
   "metadata": {},
   "outputs": [],
   "source": [
    "# First we can create a circuit to calculate the feature map \n",
    "def projected_q_feature_map(x):\n",
    "    cir = UAnsatz(2)\n",
    "\n",
    "    # turn data into tensor\n",
    "    x = paddle.to_tensor(x)\n",
    "    \n",
    "    # encode the classical data into a quantum state\n",
    "    cir.iqp_encoding(x, pattern=[[0, 1]])\n",
    "    \n",
    "    # run the circuit with state vector mode\n",
    "    cir.run_state_vector()\n",
    "    \n",
    "    # Update the progress bar\n",
    "    global N\n",
    "    pbar.update(100/N)\n",
    "    \n",
    "    # to measure the final state with Pauli measurement on every single qubit\n",
    "    return [cir.expecval([[1.0, op_pauli]]).numpy()[0] \n",
    "            for op_pauli in ['z0', 'z1', 'x0', 'x1', 'y0', 'y1']]\n",
    "\n",
    "# to compute the projected quantum kernel based on the feature vectors\n",
    "def p_quantum_kernel_estimator(x1, x2):\n",
    "    \n",
    "    # compute the feature vector of each data and return the kernel function value\n",
    "    p_feature_vector_1 = np.array(projected_q_feature_map(x1))\n",
    "    p_feature_vector_2 = np.array(projected_q_feature_map(x2))\n",
    "    \n",
    "    return np.exp(-((p_feature_vector_1 - p_feature_vector_2) ** 2).sum())\n",
    "\n",
    "# similarly, define the kernel matrix as required \n",
    "def p_quantum_kernel_matrix(X1, X2):\n",
    "    return np.array([[p_quantum_kernel_estimator(x1, x2) for x2 in X2] for x1 in X1])"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "round-bandwidth",
   "metadata": {},
   "source": [
    "Then, we replace the quantum kernel in the support vector machine with a projected quantum kernel, and see how the projected kernel performs on this classification task:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "id": "alert-royal",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Let's see how the PQK-SVM performs on the training on both the training and testing data:\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 720x288 with 2 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "# Set the progress bar and the total kernel evaluation number N needed for training and prediction\n",
    "pbar = tqdm(total=100, \n",
    "            desc='Training and predicting with PQK-SVM', \n",
    "            bar_format=bar_format_string)\n",
    "N = 2 * (len(X_train) ** 2 + len(X_train) ** 2 + len(X_train) * len(X_test))\n",
    "\n",
    "# Create a support vector machine with a quantum kernel\n",
    "svm_pqk = svm.SVC(kernel=p_quantum_kernel_matrix)\n",
    "\n",
    "# Train the svm with training data\n",
    "svm_pqk.fit(X_train, y_train)\n",
    "\n",
    "# See how the svm classifies the training and testing data\n",
    "predict_svm_pqk_train = svm_pqk.predict(X_train)\n",
    "predict_svm_pqk_test = svm_pqk.predict(X_test)\n",
    "\n",
    "# Calculate the accuracy\n",
    "accuracy_train = np.array(predict_svm_pqk_train == y_train, dtype=int).sum()/len(y_train)\n",
    "accuracy_test = np.array(predict_svm_pqk_test == y_test, dtype=int).sum()/len(y_test)\n",
    "\n",
    "# Visualize the result\n",
    "pbar.close()\n",
    "clear_output()\n",
    "fig, ax = plt.subplots(1, 2, figsize=[10, 4])\n",
    "ax[0].scatter(X_train[:,0], X_train[:,1], marker='o', \n",
    "              c = matplotlib.cm.coolwarm(np.array(predict_svm_pqk_train, dtype=np.float32)))\n",
    "ax[0].set_title('Prediction on training set, accuracy={:.2f}'.format(accuracy_train))\n",
    "ax[1].scatter(X_test[:,0], X_test[:,1], marker='v', \n",
    "              c = matplotlib.cm.coolwarm(np.array(predict_svm_pqk_test, dtype=np.float32)))\n",
    "ax[1].set_title('Prediction on testing set, accuracy={:.2f}'.format(accuracy_test))\n",
    "print(\"Let's see how the PQK-SVM performs on the training on both the training and testing data:\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "unavailable-stretch",
   "metadata": {},
   "source": [
    "Let's also check the decision function given by the PQK-SVM:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "id": "connected-final",
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Calculating the decision function for PQK-SVM: 100%|█████████████████████████████████████████▉|[02:37<00:00,  1.58s/it]\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "# Set the progress bar and the total kernel evaluation number N needed for visualizing the decision function\n",
    "pbar = tqdm(total=100, \n",
    "            desc='Calculating the decision function for PQK-SVM', \n",
    "            bar_format=bar_format_string)\n",
    "N = 2 * 10 ** 2 * len(X_train)\n",
    "    \n",
    "# Clear the progress bar and visualize the decision function\n",
    "visualize_decision_bound(svm_pqk)\n",
    "pbar.close()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "italic-failing",
   "metadata": {},
   "source": [
    "## Conclusion\n",
    "\n",
    "In quantum machine learning, people hope the design learning models which can gain quantum advantage by exploring the nature of quantum mechanics' laws. Recently, many connections are made  between these quantum models and kernel methods, one of the most important classical machine learning approaches. In comparison to considering a parameterized quantum circuit as a \"quantum neural network\", where we focus on the variational ansatz $U(\\theta)$, the quantum kernel methods emphasize the importance of quantum feature map $U(x)$, which describes how the classical data vectors is mapped to the quantum states. This brings new perspectives to how we can design novel quantum machine learning algorithms. Therefore, we encourage readers to together explore the performance of various quantum kernel designs on different data sets.\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "external-sterling",
   "metadata": {},
   "source": [
    "---\n",
    "\n",
    "## References\n",
    "\n",
    "[1] Schuld, Maria. \"Supervised quantum machine learning models are kernel methods.\" arXiv preprint [arXiv:2101.11020 (2021)](https://arxiv.org/abs/2101.11020).\n",
    "\n",
    "[2] Havlíček, Vojtěch, et al. \"Supervised learning with quantum-enhanced feature spaces.\" [Nature 567.7747 (2019): 209-212](https://arxiv.org/abs/1804.11326).\n",
    "\n",
    "[3] Liu, Yunchao, Srinivasan Arunachalam, and Kristan Temme. \"A rigorous and robust quantum speed-up in supervised machine learning.\" arXiv preprint [arXiv:2010.02174 (2020)](https://arxiv.org/abs/2010.02174).\n",
    "\n",
    "[4] Schuld, Maria, and Nathan Killoran. \"Quantum machine learning in feature Hilbert spaces.\" [Phys. Rev. Lett. 122.4 (2019): 040504](https://arxiv.org/abs/1803.07128).\n",
    "\n",
    "[5] Hubregtsen, Thomas, et al. \"Training Quantum Embedding Kernels on Near-Term Quantum Computers.\" arXiv preprint [arXiv:2105.02276(2021)](https://arxiv.org/abs/2105.02276).\n",
    "\n",
    "[6] Glick, Jennifer R., et al. \"Covariant quantum kernels for data with group structure.\" arXiv preprint [arXiv:2105.03406(2021)](https://arxiv.org/abs/2105.03406).\n",
    "\n",
    "[7] Huang, Hsin-Yuan, et al. \"Power of data in quantum machine learning.\" arXiv preprint [arXiv:2011.01938 (2020)](https://arxiv.org/abs/2011.01938).\n",
    "\n",
    "[8] Schölkopf, Bernhard, and Alexander J. Smola\"Learning with kernels: support vector machines, regularization, optimization, and beyond.\" [MIT Press(2002)](https://mitpress.mit.edu/books/learning-kernels)."
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.7.10"
  },
  "toc": {
   "base_numbering": 1,
   "nav_menu": {},
   "number_sections": true,
   "sideBar": true,
   "skip_h1_title": false,
   "title_cell": "Table of Contents",
   "title_sidebar": "Contents",
   "toc_cell": false,
   "toc_position": {},
   "toc_section_display": true,
   "toc_window_display": false
  },
  "varInspector": {
   "cols": {
    "lenName": 16,
    "lenType": 16,
    "lenVar": 40
   },
   "kernels_config": {
    "python": {
     "delete_cmd_postfix": "",
     "delete_cmd_prefix": "del ",
     "library": "var_list.py",
     "varRefreshCmd": "print(var_dic_list())"
    },
    "r": {
     "delete_cmd_postfix": ") ",
     "delete_cmd_prefix": "rm(",
     "library": "var_list.r",
     "varRefreshCmd": "cat(var_dic_list()) "
    }
   },
   "types_to_exclude": [
    "module",
    "function",
    "builtin_function_or_method",
    "instance",
    "_Feature"
   ],
   "window_display": false
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}
